PAT甲级 - 1098 Insertion or Heap Sort (25 分) 堆排序，找规律

According to Wikipedia:

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.

Heap sort divides its input into a sorted and an unsorted region, and it iteratively shrinks the unsorted region by extracting the largest element and moving that to the sorted region. it involves the use of a heap data structure rather than a linear-time search to find the maximum.

Now given the initial sequence of integers, together with a sequence which is a result of several iterations of some sorting method, can you tell which sorting method we are using?

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤100). Then in the next line, N integers are given as the initial sequence. The last line contains the partially sorted sequence of the N numbers. It is assumed that the target sequence is always ascending. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in the first line either "Insertion Sort" or "Heap Sort" to indicate the method used to obtain the partial result. Then run this method for one more iteration and output in the second line the resulting sequence. It is guaranteed that the answer is unique for each test case. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0

Sample Output 1:

Insertion Sort
1 2 3 5 7 8 9 4 6 0

Sample Input 2:

10
3 1 2 8 7 5 9 4 6 0
6 4 5 1 0 3 2 7 8 9

Sample Output 2:

Heap Sort
5 4 3 1 0 2 6 7 8 9

纸上得来终觉浅，觉知此事要躬行。

1. 涉及到HeapSort，数组从1开始计数
2. 初始序列不能参与比较
3. HeapSort（），从n/2开始，循环初始化。 

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 110;
vector<int>origin, target, temp; //temp进行一步步排序，然后与changed进行比较
int n;

bool InsertSort() {	int flag = 0;
	for (int i = 2; i <= n; i++) {
		sort(temp.begin() + 1, temp.begin() + 1 + i);
		if (temp == target)
		{
			sort(temp.begin() + 1, temp.begin() + i + 2);
			flag = 1;
			break;
		}
	}
	if (flag == 1) {
		printf("Insertion Sort\n");
		for (auto it = temp.begin() + 1; it != temp.end(); it++) {
			if (it != temp.begin() + 1)
				printf(" ");
			printf("%d", *it);
		}
	}
	return flag;
}
void downAdjust(vector<int>& temp, int low, int high) { //插入堆后，downAdjust
	int i = low, j = i * 2;
	while (j <= high) {
		if (j + 1 <= high && temp[j + 1] > temp[j]) {
			j = j + 1;
		}
		if (temp[j] > temp[i]) { //如果根节点不是最大的
			swap(temp[i], temp[j]);
			i = j;
			j = j * 2;
		}
		else {
			break;
		}
	}
}
void HeapSort() {
	int flag = 0;
	for (int i = n / 2; i >= 1; i--) {
		downAdjust(temp, i, n);
	}
	for (int i = n; i >= 1; i--)
	{
		swap(temp[i], temp[1]);
		downAdjust(temp, 1, i - 1);
		if (flag == 1)
			break;
		if (temp == target) {
			flag = 1;
		}
	}
	if (flag == 1) {
		for (auto it = temp.begin() + 1; it != temp.end(); it++) {
			if (it != temp.begin() + 1)
				printf(" ");
			printf("%d", *it);
		}
	}
}
int main() {
	scanf("%d", &n);
	int v;
	origin.push_back(-1);
	temp.push_back(-1);
	target.push_back(-1);
	for (int i = 0; i < n; i++) {
		scanf("%d", &v);
		origin.push_back(v);
		temp.push_back(v);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &v);
		target.push_back(v);
	}
	if (!InsertSort()) {
		printf("Heap Sort\n");
			for (int i = 1; i < origin.size(); i++) {
				temp[i] = origin[i];
			}
		HeapSort();
	}

	return 0;
}

但是，如果仅仅是为了完成这道题的话，可以有更简单的思路来做：

/*
insert sort的特点，前p个数字有序，后n-p个数字顺序不变
heap sort特点，后p个数字有序，且都大于第一个数字，第一个数字是n-p序列的最大值
*/
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;

void downAdjust(vector<int>& b, int low, int high) {
	int i = low, j = i * 2;
	while (j <= high) {
		if (j + 1 <= high && b[j + 1] > b[j]) j++;
		if (b[i] < b[j])
		{
			swap(b[i], b[j]);
			i = j;
			j = i * 2;
		}
		else break;
	}
}
int main() {
	int n, p = 2;//p是游标
	scanf("%d", &n);
	vector<int> a(n + 1), b(n + 1); // 涉及到堆，序列从1开始
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
	for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
	while (p <= n && b[p - 1] <= b[p]) p++;
	int index = p;
	while (p <= n && a[p] == b[p]) p++;
	if (p == n + 1) {
		printf("Insertion Sort\n");
		sort(b.begin() + 1, b.begin() + 1 + index); //排序，排到应排序列的下一个元素
	}
	else { //那么一定是堆排序，从后向前找到第一个小于b[1]的数即可
		printf("Heap Sort\n");
		p = n;//从后向前遍历
		while (p > 2 && b[p] >= b[1]) p--;
		swap(b[1], b[p]);
		downAdjust(b, 1, p - 1);
	}
	for (int i = 1; i <= n; i++) {
		if (i != 1)
			printf(" ");
		printf("%d", b[i]);
	}

	return 0;

}