1098 Insertion or Heap Sort (堆排序和插入排序）

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

 

本题题意 给定 n个数， 并给定这n个数排了部分序列的数值 放入b[i]数组中 ， （排序这组数据有两种方式，一种是插入排序， 一种是堆排序，

） 此时需要判断 这组排序了部分数字的序列属于那种排序， 判断后 并输出下一步对应排序应该输出的序列。

本题思路：

1.对于插入排序的序列 序列从左到右是从小到大排列， 当遇到不适配处（并不满足从小到大） 它的序列应该与原序列相同

   因此通过这个特性，可以进行快速排序：

  找到不适配的i点，将起始点 - i点重新排序就是 下一步插入排序的序列

 起始点是从i=1开始的:

sort(b.begin() + 1, b.begin() + p + 1);

2.对于堆排序的序列， 序列的结尾处是从小到大排列，

   序列的结尾处从小到大排好序的点都 大于 b[0], 未排序的值都小于b[0],因此此时 从b数组的后面往前方向找到第一个比b[0]小的值 并与b[0]交换， 然后重新构建大顶堆（此时除了第一个元素其余元素都满足大顶堆的条件）（构建的方式可以通过递归与迭代两种方式实现）

具体代码的实现：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int n , p = 0;
vector<int> a, b; //a数组为原数值（快速排序对比）， b数组为原数值排好的部分序列 
bool isheap = false;
//void heapifySort(int start, int end){ //递归方法重新构造堆 
//	if(start > end ) 
//		return;
//	int left = 2 * start;
//	int right = 2 * start + 1;
//	int max = start;
//	if(b[left] > b[max] && left <= end)
//		max = left;
//	if(b[right] > b[max] && right <= end)  //
//		max  = right;
//	if(max != start){
//		swap(b[max], b[start]);
//		heapifySort(max, end);
//	}
//}
void heapifySort(int low, int high) { //迭代的方式实现向下重新构造大顶堆 
    int i = 1, j = i * 2;
    while(j <= high) {
        if(j + 1 <= high && b[j] < b[j + 1]) j = j + 1;
        if (b[i] >= b[j]) break;
        swap(b[i], b[j]);
        i = j; j = i * 2;
    }
}
void sortOut(bool isheap){
	if(isheap == false){ //快速排序 
		sort(b.begin() + 1, b.begin() + p + 1);
	}else{ //堆排序 
		p = n;
		while(p > 2 && b[p] >= b[1])
			p--;
		swap(b[p], b[1]); //交换第一个不适配的元素 
		heapifySort(1, p - 1);
	}
}
int main(){
	scanf("%d", &n);
	a.resize(n + 1);
	b.resize(n + 1);
	for(int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	for(int  i = 1; i <= n; i++)
		scanf("%d", &b[i]);
	
//	p = 2;
//	while(p <= n && b[p - 1] <= b[p]) p++;
//    int index = p;
//    while(p <= n && a[p] == b[p]) p++;
//    if(p != n + 1) {	
//    	isheap = true;
//    }else{
//    	p = index;
//	}	
	for(int i = 1; i < n; i++){
		if(b[i] > b[i + 1]){
			p = i + 1;
			int index = p; //此时的index就为快速排序的第一个不适配点 
//			for(int j = i + 1; j <= n; j++){
//				if(a[j] != b[j])
					isheap = true;
					break;
//			}
			for(; p <= n && a[p] == b[p]; p++){
			}
			if(p != n + 1){
				isheap = true;
			}else{
				p = index;
			}
			break;
		}
//		if(isheap == true)   错误在这个位置 只有isheap = true 才会跳出循环，应该
//						     是执行了if就要跳出循环 
//			break;
	}

	sortOut(isheap);
	if(isheap == true)
		printf("Heap Sort\n");
	else
		printf("Insertion Sort\n");
	for(int i = 1; i <= n; i++){
		printf("%s%d", i == 1 ? "" : " ", b[i]);
	} 
	return 0;
}