A1098. 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 resuling 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

堆拍下排序，每一次的过程，用形象语言，就像向沙堆里扬沙子，用铲子将堆底的沙子扬上去，沙子再从上面落下来。
插入排序的特点是：b数组前面的顺序是从小到大的，后面的顺序不一定，但是一定和原序列的后面的顺序相同~~所以只要遍历一下前面几位，遇到不是从小到大的时候，开始看b和a是不是对应位置的值相等，相等就说明是插入排序，否则就是堆排序啦

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> a, b;//a第一行原始，b第二行目标
void downAdjust(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]) {
            swap(b[i], b[j]);	//让父亲最大
            i = j; j = i * 2;
        } else {
            break;	//一次只调整一次，所以break
        }
    }
}
int main() {
    int n, p = 2;
    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]);
    while(p <= n && b[p - 1] <= b[p]) p++;//按递增顺序，p为第一个非递增位置
    int index = p;
    while(p <= n && a[p] == b[p]) p++;//如果跑到头，a和b后边的都相等，说明是插入排序，后边的没来得及插入呢
    if(p == n + 1) {
        printf("Insertion Sort\n");
        sort(b.begin() + 1, b.begin() + index + 1);//插入index+1排序
        printf("%d", b[1]);
        for(int i = 2; i <= n; i++)
            printf(" %d", b[i]);
    } else {
        printf("Heap Sort\n");
        p = n;
        while(p >= 2 && b[p] >= b[p - 1]) p--;//p为从后数第一个非递减位置
        swap(b[1], b[p]);
        downAdjust(1, p - 1);//堆排序，每一次都是先交换当前和堆顶，再将余下的排序。堆排序就像向沙堆里扬沙子，用铲子将堆底的沙子扬上去，沙子再从上面落下来。
        printf("%d", b[1]);
        for(int i = 2; i <= n; i++)
            printf(" %d", b[i]);
    }
    return 0;
}

另附晴神的代码，略高深看懂了但是没过样例，也可以参考一下规范的写法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
#include<queue>
using namespace std;
const int N=111;
int origin[N],tempOrigin[N],changed[N];
int n;
bool isSame(int A[],int B[]){
	for(int i=1;i<=n;i++){
		if(A[i]!=B[i])
			return false;
	}
	return true;
}
void showArray(int A[]){
	for(int i=1;i<=n;i++){
		printf("%d",A[i]);
		if(i<n)
			printf(" ");
	}
	printf("\n");
}
bool insertSort(){
	//这一次相等了，输出下一次排序，故先判断相等，后排序
	bool flag=true;
	for(int i=2;i<=n;i++){//插入排序从第二个数开始
		if(i!=2&&isSame(tempOrigin,changed))
			flag=true;
		sort(tempOrigin,tempOrigin+i+1);//不理解为啥+1
		showArray(tempOrigin);
		if(flag==true)
			return true;
	}
}
void downAdjust(int low,int high){
	int i=low;int j=2*i;//左孩子
	while(j<=high){ //存在孩子
	if(tempOrigin[j]<tempOrigin[j+1]&&j+1<=high)
		j++;	//取左右孩子最大的
	if(tempOrigin[i]<tempOrigin[j]){	//根最大
			swap(tempOrigin[i],tempOrigin[j]);
			i=j;
			j=2*i;
		}
	else break;//一次只调整一次，所以break
	}
}
void heapSort(){
	bool flag=false;
	for(int i=n/2;i>=1;i--){
		downAdjust(i,n);//建堆
	}
	for(int ii=n;ii>1;ii--){//先判断是，再求下一个
		if(ii!=n&&isSame(tempOrigin,changed))
			flag=true;
		swap(tempOrigin[ii],tempOrigin[1]);
		downAdjust(1,ii-1);//到i=2为止所以i-1。
		if(flag==true)
		{
			showArray(tempOrigin);
			return;
		}

	}
}
int main()
{
	//freopen("data.in","r",stdin);
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&origin[i]);
		tempOrigin[i]=origin[i];
	}
	for(int ia=1;ia<=n;ia++)
	{
		scanf("%d",&changed[ia]);
	}
	if(insertSort()){
		printf("Insertion Sort\n");
		showArray(tempOrigin);
	}
	else{
		printf("Heap Sort\n");
		for(int i=1;i<=n;i++){
			tempOrigin[i]=origin[i];//还原
		}
		heapSort();
	}
	return 0;
}