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 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

轉載來自: 堆排序感覺自己寫出來還是需要時間的嚶嚶嚶

https://blog.csdn.net/qq_33657357/article/details/82414686

程式碼

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 110;
int ori[maxn],tempori[maxn],changed[maxn];//原始陣列，原始備份陣列，目標陣列
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 print(int a[]) //輸出陣列
{
	for(int i = 1;i <= n;i++)
		printf("%d%c",a[i]," \n"[i==n]);
}
bool insertSort()//插入排序
{
	bool flag = false;
	for(int i = 2;i <= n; i++)
	{
		if(i != 2 && isSame(tempori,changed))
			flag = true;
		sort(tempori,tempori + i + 1);
		if(flag == true)
			return true;
	}
	return false;
}
void downAdjust(int low,int high)//向下調整,O(logN)  最大堆啊 
{
	int i = low,j = i * 2;//i為欲調整結點，j為其左孩子
	while(j <= high)//存在孩子結點 
	{
		if(j + 1 <= high && tempori [j + 1]> tempori[j])//如果右孩子存在且右孩子的值大於左孩子 
			j = j + 1;//讓j儲存右孩子下標 
		if(tempori[j]>tempori[i]) //孩子中最大的那個比要調整的結點i大
		{
			swap(tempori[j],tempori[i]);//交換二者
			i = j; //始終保持i為需要調整的結點，j為i的孩子 
			j = i * 2;
		}
		else break;//孩子結點權值均比欲調整結點i要小，調整結束
	}
}
void heapSort()
{
	bool flag = false;
	for(int i = n / 2;i >= 1; i--)
		downAdjust(i,n);	//建堆
	for(int i = n;i > 1; i--)
	{
		if(i != n && isSame(tempori,changed))
			flag = true;
		swap(tempori[i],tempori[1]); 
		downAdjust(1, i - 1); //i - 1要調整的個數 
		if(flag == true)
			return; 
	}
}
int main()
{
	scanf("%d",&n);
	for(int i = 1;i <= n; i++)
	{
		scanf("%d",& ori[i]);
		tempori[i] = ori[i];
	}
	for(int i = 1;i <= n;i++)
		scanf("%d",&changed[i]);//讀入目標陣列
	if(insertSort())
	{
		printf("Insertion Sort\n");
		print(tempori);
	}
	else
	{
		printf("Heap Sort\n");
		for(int i = 1;i <= n;i++)
			tempori[i] = ori[i];
		heapSort();
		print(tempori);
	}
	return 0;
}