【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 resuling 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）如何判断是否是插入排序？
 排序前的数组称为orgin，排序后的数组成为sorted。如果采用的是插入排序，那么sorted前部分是递增的，而后部分是和origin相同的。
（2）最大堆
最大堆的特性是父节点的值大于所有子节点的值。采用数组表示最大堆，则下标为i的节点的左儿子节点下标为2*i+1,右儿子节点下标为2*i+2。 
以  6 4 5 1 0 3 2 7 8 9  为例，（7，8，9）为排好序的元素，（6 4 5 1 0 3 2）为堆中元素且6为根。下一步操作就是把6从跟的位置进行下移操作：将6与左右儿子节点值较大的那个交换。一直到6交换到了末尾（5 4 3 1 0 2 6）

正确AC代码如下：
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

void swap(vector<int> &vec, int now, int change){
	int tmp;
	tmp = vec[now];
	vec[now] = vec[change];
	vec[change] = tmp;
}

int main(int argc, char** argv) {
	int n, i;
	scanf("%d",&n); 
	vector<int> origin(n);
	for(i=0; i<n; i++){
		scanf("%d",&origin[i]);	 
	}
	vector<int> sorted(n);
	for(i=0; i<n; i++){
		scanf("%d",&sorted[i]);
	}

	int index = i;
	bool isInsert = true;
	for(i=0; i<index; i++){
		if(sorted[i] > sorted[i+1]){
			index = i+1;
		}
	}	
	for(i=index; i<n;  i++){
		if(origin[i] != sorted[i]){
			isInsert = false;
			break;
		}
	}

 
	if(isInsert){
		//是插入排序
		printf("Insertion Sort\n");
		priority_queue<int, vector<int>, greater<int> > que;
		for(i=0; i<=index; i++){
			que.push(origin[i]);
		}
		printf("%d",que.top());
		que.pop();
		while(!que.empty()){
			printf(" %d",que.top());
			que.pop();
		}
		for(i=index+1; i<n; i++){
			printf(" %d",origin[i]);
		}
		printf("\n");
	}else{
		//是堆排序
		printf("Heap Sort\n");
	    sort(origin.begin(), origin.end());
		for(i=n-1; i>0; i--){
			if(origin[i] != sorted[i]){
				index = i;
				break;
			}			
		}	
		int sortedMin = origin[index];	 
		int left, right;
		int now = 0;
		int tmp;
		int t;
		while(now != index){
		 	left = now*2+1;
			right = now*2+2;
			if(right <= index){
				if(sorted[left] < sorted[right]){				 
					swap(sorted, now, right);
					now = right;
				}else{
					swap(sorted, now, left);
					now = left;
				}
			}else if(left <= index){
				swap(sorted, now, left);
				now = left;		
			}else{
				swap(sorted, now, index);
				break;
			} 
		} 			
		
		for(i=0; i<n; i++){
			if(i==0)
			    printf("%d", sorted[i]);
			else
			    printf(" %d",sorted[i]);
		}
		printf("\n");
	}
	return 0;
}