【PAT】A1098 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

题意

给出一个初始序列和一个中间序列，求这个中间序列是由堆排序得到还是由插入排序得到，并输出下一轮排序后的序列。

思路

写出排序算法，从第二次排序开始，每一次排序前检查是否相等，如果是，则在该轮排序后终止函数，并返回结果。当然题目说了一定是两种排序中的一种，我们先检查是否是堆排序，所以InsertSort()不需要返回值。因为堆排序中下标从1开始，为了方便，我们干脆将所有的序列下标都从1开始存储，所以边界条件和循环语句略有变化。

代码

#include <cstdio>
#include <algorithm>
#define MAX_N 101
int insertion[MAX_N], heap[MAX_N], target[MAX_N];
int N;

// 检查是否相同
bool check(int a[], int b[]){
    for(int i = 1; i <= N; i++){
        if(a[i] != b[i]) return false;
    }
    return true;
}

// 打印序列
void printArr(int a[]){
    printf("%d", a[1]);
    for(int i = 2; i <= N; i++){
        printf(" %d", a[i]);
    }
}

// 交换
void swap(int a[], int i, int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

// 下沉
void sink(int k, int l){
    int j;
    while ((j = 2 * k) <= l) {
        if(j < l && heap[j + 1] > heap[j]) j++;
        if(heap[j] <= heap[k]) break;
        swap(heap, k, j);
        k = j;
    }
}

// 堆排序
bool heapSort(){
    // 复制一份
    std::copy(insertion + 1, insertion + N + 1, heap + 1);
    
    // 建立堆
    for(int k = N / 2; k > 0; k--){
        sink(k, N);
    }
    
    
    // 排序
    bool flag = false;
    for(int i = N; i > 0; i--){
        // 不是初始序列且堆序列和目标序列相同
        if(i < N && check(heap, target)){
            flag = true;
        }
        swap(heap, 1, i);
        sink(1, i - 1);
        
        // flag为true之后再排序一次，然后退出
        if(flag){
            return true;
        }
    }
    
    return false;
}

// 插入排序
void insertSort(){
    bool flag = false;
    for(int i = 1; i < N; i++){
        if(i > 1 && check(insertion, target)){
            flag = true;
        }
        for(int j = i + 1; j > 1 && insertion[j] < insertion[j - 1]; j--){
            swap(insertion, j, j - 1);
        }
        if(flag){
            return;
        }
    }
}
int main() {
    scanf("%d", &N);
    for(int i = 1; i <= N; i++){
        scanf("%d", &insertion[i]);
    }
    for(int i = 1; i <= N; i++){
        scanf("%d", &target[i]);
    }
    
    if(heapSort()){
        printf("Heap Sort\n");
        printArr(heap);
    }else{
        insertSort();
        printf("Insertion Sort\n");
        printArr(insertion);
    }
    return 0;
}