PAT甲级——1098 Insertion or Heap Sort (插入排序、堆排序)

本文同步发布在CSDN：https://blog.csdn.net/weixin_44385565/article/details/90941941

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 (≤). 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个数据进行排序，给出排序过程中的数据，判断是插入排序还是堆排序，然后输出下一步排序得到的数列。

思路：判断排序方法，前面是从小到大排列，后面的数据跟原始数据相同的就是插入排序，否则为堆排序。

插入排序的下一步操作就是把下一个数字插入到前面合适的位置。

堆排序的首个数字是当前大顶堆的根，将它与堆的最后一个节点（从后往前找，第一个小于根节点的数就是当前堆的最后一个节点）交换位置，然后再对根节点进行堆化操作。

测试点0、2、4是插入排序，1、3、5是堆排序。（不要问我是怎么知道的~）

 #include <iostream>
 #include <vector>
 using namespace std;
 int N;
 vector <int> v1, v2;
 int maxIndex(int a, int b, int c, int n);
 bool fun();
 void adjust(int index, int n);
 void swap(int& a, int& b);
 int main()
 {
     scanf("%d", &N);
     v1.resize(N);
     v2.resize(N);
     for (int i = ; i < N; i++)
         scanf("%d", &v1[i]);
     for (int i = ; i < N; i++)
         scanf("%d", &v2[i]);
     bool flag = fun();//判断排序方式
     if (flag) {//插入排序
         int index, tmp, j;
         for (int i = ; i < N; i++)
             if (v2[i] < v2[i - ]) {
                 index = i;
                 tmp = v2[index];
                 break;
             }
         for (j = index; j >  && v2[j - ] > tmp; j--)
             v2[j] = v2[j - ];
         v2[j] = tmp;
         printf("Insertion Sort\n");
     }
     else {//堆排序
         int index, tmp;
         for (int i = N - ; i >= ; i--)
             if (v2[] > v2[i]) {
                 index = i;
                 tmp = v2[index];
                 break;
             }
         v2[index] = v2[];
         v2[] = tmp;
         adjust(, index - );
         printf("Heap Sort\n");
     }
     for (int i = ; i < N; i++) {
         printf("%d", v2[i]);
         if (i < N - )
             printf(" ");
     }
     return ;
 }
 void adjust(int index, int n) {
     int max;
     while (index *  +  <= n ) {
         max = maxIndex(index, index *  + , index *  + , n);//寻找当前节点与其孩子之间的最大值的下标
         if (index == max)//若最大值是自己，则退出循环
             break;
         swap(v2[index], v2[max]);
         index = max;
     }
 }
 int maxIndex(int a, int b, int c, int n) {
     if (v2[b] > v2[a])
         a = b;
     if (c <= n && v2[c] > v2[a])
         a = c;
     return a;
 }
 void swap(int& a, int& b) {
     int c = a;
     a = b;
     b = c;
 }
 bool fun() {
     int i, index = ;
     for (i = ; i < N; i++)
         if (v2[i] < v2[i - ]) {
             index = i;
             break;
         }
     for (int i = index; i < N; i++) {
         if (v1[i] != v2[i])
             return false;
     }
     return true;
 }