1045. 快速排序

著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的N个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？

例如给定N = 5, 排列是1、3、2、4、5。则：

• 1的左边没有元素，右边的元素都比它大，所以它可能是主元；

• 尽管3的左边元素都比它小，但是它右边的2它小，所以它不能是主元；

• 尽管2的右边元素都比它大，但其左边的3比它大，所以它不能是主元；

• 类似原因，4和5都可能是主元。

因此，有3个元素可能是主元。

输入格式：

输入在第1行中给出一个正整数N（<= 105）； 第2行是空格分隔的N个不同的正整数，每个数不超过109。

输出格式：

在第1行中输出有可能是主元的元素个数；在第2行中按递增顺序输出这些元素，其间以1个空格分隔，行末不得有多余空格。

输入样例：

5
1 3 2 4 5

输出样例：

3
1 4 5

---

解题思路：

题目看上去很简单，但给出的 N 很大，如果只是简单的按照其规则进行比较，一定会超时。

先导：
将给出的数字复制到另一个数组 (temp) 里，进行排序：

排列前：1 3 2 4 5
排列后：1 2 3 4 5

排列后的数组中，每一个数字大于前面的数字，小于后面的数字。这跟主元的特征是一致的，这表明，如果一个数是被选取的主元，那么它在数组中的位置在排序后不会发生变化。那么 1 4 5 便有可能是主元，但不一定就是主元。比如：

排列前：1 2 5 4 3
排列后：1 2 3 4 5

这里面的 4 就不是主元。说明原位置与排序后的位置相同是其必要而不充分条件。

详细思路：

概要：先将数组排序，然后从最大值开始逆序排除非主元数。如果最大值不在末尾，那么最大值及它之后的元素都不可能是主元，排除这些元素，缩短了序列长度，再看下一个最大值，继续往下走。如果最大值在末尾且其原始位置和排序后的位置一致则是主元，记录下来。重复上面的判断。

多写出几组数据，就可以发现有这样一个规律：

比如原始数组：

1 3 5 2 4 6 9 8 7

顺序排列后：

1 2 3 4 5 6 7 8 9

先看原始数组，其中 9 是最大值，9 如果不在末尾，在 9 及 9 后面的元素 9 和 7 都不可能是主元。于是我们划掉 9、8、7：

1 3 5 2 4 6 9 8 7

剩下的值最大的为 6。6 后面没有数字，说明 6 有可能是主元。

如果 6 是主元，那么 6 的前面应有 5 个比它小的元素，后面应有 3 个比它大的元素。顺序排列后的数组中的 6 的位置就满足这一要求。

6 所在位置（数组下标）是 5，与按顺序排列后的位置（排列后的 6 数组下标也为 5） 一致，这个时候，可以判断 6 一定是主元元素。因为它与排列后的 6 的位置一致，说明前面一定有 5 个元素，而它又是当前序列的最大值，说明这个 6 比前面的 5 个元素都大，因而也可推知比它后面的元素都小，因为 6 的前面只可能有 5 个元素，而这 5 个又都比它小，说明大的都在它之后。

这样就得到了一个主元 6，存入 target 数组中。再删去后面 4 个元素：

1 3 5 2 4 6 9 8 7

接下来，最大值是 5，5 的后面有2 4，这样 5、2、4 就不可能是主元。就再删去 5 2 4。

1 3 5 2 4 6 9 8 7

接下来，最大值 3，与顺序排列后 3 的位置不一致，肯定不是主元。删掉 3。继续处理：

1 3 5 2 4 6 9 8 7

接下来，最大值是 1，与顺序排列后的位置一致，则它是主元。于是我们得到了所有结果。

[后记]
搜索了其它童鞋的思路，发现只要与顺序排列后的数组比较就可以了，只需要额外添加一个变量记录从 0 到当前位置的最大值 max。如果正在处理的数与顺序排列后的一致，又等于这个最大值，说明它就是主元。这样的代码更简单些，无需使用结构来记录原编号了。

这篇代码也不算复杂，不过多个思路总是好些。

😃

解题代码：

#include<stdio.h> 
#include<stdlib.h>

int compare (const void *p, const void *q);

struct array {
	int number;
	int id; // 记录在原始数组中的位置 
}; 

int main () 
{	 
	int N;
	scanf ("%d\n", &N);
	struct array a[N], temp[N];
	for (int i=0; i<N; i++) {
		scanf ("%d", &a[i].number);
		temp[i].number = a[i].number;
		a[i].id = i;
		temp[i].id = i;  
	}
	qsort (temp, N, sizeof (struct array), compare);
	
	int count = 0;
	int target[N];
	int temp_N = N - 1; // 初始化为数组最后一个元素下标 
	for (int i=N-1; i>=0; i--) {
		if (temp[i].id < temp_N) {
			temp_N = temp[i].id - 1; // 如果这个最大值不在末尾，将 N 的范围减小至这个数的前一位 
		} else if (temp[i].id == temp_N) {
			if (temp[i].id == i) {
				target[count++] = temp[i].number;
			} // 如果原位置等于排列后的位置，则是主元 
			temp_N = temp[i].id - 1;
		}
	}
	printf ("%d\n", count);
	if (count) {
		for (int i=count-1; i>0; i--) {
			printf ("%d ", target[i]);
		}
		printf ("%d\n", target[0]);
	} else {
		printf ("\n"); // 0 个不输出，但要输出回车 
	}
	
	return 0;
} 

int compare (const void *p, const void *q) {
	int x = (*(struct array *)p).number;
	int y = (*(struct array *)q).number;
	if (x > y) {
		return 1;
	} else if (x < y) {
		return -1;
	}
	return 0;
}