PAT甲级—— Insertion or Heap Sort

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

思路：这道题需要模拟插入排序和堆排序的每一步过程。具体做法为先进行插入排序如果执行过程中发现与给定的序列吻合，那么说明是插入排序，计算出下一步将会产生的序列后结束算法；如果不是插入排序，那么一定是堆排序，模拟堆排序的过程，如果执行过程中发现与给定的序列吻合，那么计算出下一步将会产生的序列后结束算法。

代码：

#include <iostream>
#include<algorithm>
using namespace std;
const int N = 111;
int origin[N], tempOri[N], changed[N];//原始数组、原始数组备份及目标数组
int n;//元素个数

bool isSame(int A[], int B[]) {//判断A和B数组是否相同
	for (int i = 1; i <= n; i++)
	{
		if (A[i] != B[i]) return false;
	}
	return true;
}

void showArray(int A[])//输出数组
{
	for (int i = 1; i <= n; i++)
	{
		printf("%d", A[i]);
		if (i < n) printf(" ");
	}
	printf("\n");

}

bool insertSort() {//插入排序
	bool flag = false;//记录是否在数组中间步骤与changed数组相同
	for (int i = 2; i <= n; i++)//进行n-1趟排序
	{
		if (i != 2 && isSame(tempOri, changed)) {
			flag = true;//中间步骤与目标相同，且不是初始序列
		}
		//插入部分直接用sort代替
		sort(tempOri, tempOri + i + 1);
		if (flag == true) {
			return true;
		}
	}
	return false;//无法到达目标数组，返回false

}

//对heap数组在[low,high]范围内进行调整
//其中low为预调整结点的数组下标，high一般为堆的最后一个元素的数组下标
void downAdjust(int low, int high)
{
	int i = low, j = i* 2;//i为欲调整结点，j为其左孩子结点
	while (j<=high)//存在孩子结点
	{//如果右孩子存在，且右孩子的值大于左孩子的值
		if (j + 1 <= high && tempOri[j + 1] > tempOri[j]) {
			j = j + 1;//让j储存右孩子结点下标
		}
		//如果孩子结点中最大的权值比父亲结点大
		if (tempOri[j] > tempOri[i])
		{
			swap(tempOri[j], tempOri[i]);//交换最大权值的孩子结点与父亲结点
			i = j;//令i为j，令j为i的左孩子结点，进入下一层
			j = i * 2;
		}
		else {
			break;//孩子结点的权值均比父亲结点的小，调整结束
		}
	}

}

void heapSort() {//堆排序
	bool flag = false;
	for (int i = n / 2; i >= 1; i--)
	{
		downAdjust(i, n);//建堆
	}
	for (int i = n; i > 1; i--)
	{
		if (i != n && isSame(tempOri, changed)) {
			flag = true;//中间步骤与目标相同，且不是初始序列
		}
		swap(tempOri[i], tempOri[1]);//交换heap[i]与堆顶
		downAdjust(1, i - 1);
		if (flag == true) {
			showArray(tempOri);
			return;
		}
	}
}

int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &origin[i]);
		tempOri[i] = origin[i];//tempOri为数组备份，排序在tempOri上面进行
	}
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &changed[i]);//目标数组
	}
	if (insertSort())
	{
		printf("Insert Sort\n");
		showArray(tempOri);
	}
	else {//到达此处时一定是堆排序
		printf("Heap Sort\n");
		for (int i = 1; i <= n; i++)
		{
			tempOri[i] = origin[i];//还原tempOri数组
		}
		heapSort();//堆排序

	}
	return 0;

}