PAT Insertion or Heap Sort

Insertion or Heap Sort

题目

给定一段初始序列和一段已经排序部分的序列，判断是插入排序还是堆排序。

思路

和Insert or Merge差不多，但是判断堆排序更简单。众所周知堆排序的顺序从大从小进行的，即已经排好序的部分位于数组的后面，未排好序的部分位于数组的前面部分，并且第一个位置就是堆顶，如果是大根堆的话，就是元素最大的位置。我们的任务是需要找到已经排好部分和未排好部分的分界线。

如何找到这个分界点，简单，从后往前遍历直到一个节点的父节点的数据比他大，此时的位置$i$就是分界点，为什么呢，因为对于后面已经排好序的元素，比他大的数据只可能在他的后面（堆排序从大到小排序），如果假定他仍在堆上，他的父节点的数据必须就必须比他大，而用数组的方式存储时，父节点在这个点的前面，就与前面所说的矛盾，所以可知对于第一个父节点数据比自身数据大的位置$i$，就是已排区域和未排区域的分界点。

#include <iostream>
#include <algorithm>
using namespace std;
int N;
int A[110], B[110], Tmp[110];

int judge_Insert() {
    // 判断是否是插入排序
    int i;
    for (i = 1; i < N; i++) {
        if(B[i] < B[i-1]) break;
    }
    for (int j = i; j < N; j++) {
        if (B[j] != A[j]) return -1;
    }
    return i;
}

void Insertion_Sort(int P) {
    //把到位置P为止的序列排的有序
    int dat = B[P], j;
    for (j = P; j > 0 && B[j-1] > dat; j--) {
        B[j] = B[j-1];
    }
    B[j] = dat;
    for (int i = 0; i < N; i++) {
        cout << B[i];
        if (i != N-1) cout << " ";
    }
}

//堆的下滤
void sink(int i, int n) {
		//由于数组的下标从0开始，其子节点的下标为2*i+1和2*i+2。
	   while (2*i+1 < n) {
       		int j = 2*i+1;
        	if (j < n-1 && B[j] < B[j+1]) j++;
        	swap(B[i], B[j]);
        	i = j;
    	}
}

void Heap_Sort() {
    // 堆排序的后面部分是有序的且从大到小递减
    int i;
    for (i = N-1; (i-1)/2 >= 0; i--) {
    	//由于数组的下标从0开始，其父节点的下标为(i-1)/2。
        if (B[(i-1)/2] > B[i]) break;
    }
    //有序部分从i开始
    swap(B[0], B[i]);
    sink(0, i);
    for (int i = 0; i < N; i++) {
        cout << B[i];
        if (i != N-1) cout << " ";
    }
}

void solve() {
    int f;
    f = judge_Insert();
    if (f != -1) {
        cout << "Insertion Sort" << endl;
        Insertion_Sort(f);
    } else {
        cout << "Heap Sort" << endl;
        Heap_Sort();
    }
}

int main() {
    cin >> N;
    for (int i = 0; i < N; i++) cin >> A[i];
    for (int i = 0; i < N; i++) cin >> B[i];
    solve();
    return 0;
}