PAT_（堆）1098 Insertion or Heap Sort (25分)

 

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

题意：给定一个待排序的sequence，选择用insertion sort 或是 heap sort排序；target sequence为排序过程的中间一步，先根据insertion sort / heap sort 判断是用了哪种排序，然后再输出用这种排序的下一步的结果 

insertion sort中间结果的特点：类似于洗牌，前面部分是sorted sequence，后面unsorted 部分和原序列一样；

3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0   样例1解释，sorted区（1 2 3 7 8） unsorted区（5 9 4 6 0）

heap sort中间结果的特点：首先我们对n个数字构造最大堆，然后取堆顶元素，放到最后，调整堆（对于剩下的元素）；

故sequence的最后部分是有序的；

3 1 2 8 7 5 9 4 6 0
6 4 5 1 0 3 2 7 8 9   样例2解释：（7 8 9）是已经排好序放到最后的元素，6是除了（7 8 9）以外剩下元素的堆顶，

显然下一步的sequence就是6与2 做swap，然后对于（6 7 8 9）的前面的部分进行堆调整

由于insertion sort的中间结果比较好判断，所以判断不是insertion sort就是heap sort

代码：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
void downAdjust(vector<int> &b, int low, int high) {//max_heap下滤 
    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;
    }
}
int main() {
    int n, p = 2;
    scanf("%d", &n);
    vector<int> a(n + 1), b(n + 1);
    for(int i = 1; i <= n; i++) //注意index从1开始 left=2*x 
	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() + index + 1);
    } else {
        printf("Heap Sort\n");
        p = n;
        while(p > 2 && b[p] >= b[1]) p--;//从后向前找大于堆顶的元素，的前一个  
        swap(b[1], b[p]);
        downAdjust(b, 1, p - 1);
    }
    printf("%d", b[1]);
    for(int i = 2; i <= n; i++)
        printf(" %d", b[i]);
    return 0;
}