7-4 插入排序还是堆排序

根据维基百科的定义：

插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。

堆排序也是将输入分为有序和无序两部分，迭代地从无序部分找出最大元素放入有序部分。它利用了大根堆的堆顶元素最大这一特征，使得在当前无序区中选取最大元素变得简单。

现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？

输入格式：

输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。

输出格式：

首先在第 1 行中输出Insertion Sort表示插入排序、或Heap Sort表示堆排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。

输入样例 1：

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0

输出样例 1：

Insertion Sort
1 2 3 5 7 8 9 4 6 0

输入样例 2：

10
3 1 2 8 7 5 9 4 6 0
6 4 5 1 0 3 2 7 8 9

输出样例 2：

Heap Sort
5 4 3 1 0 2 6 7 8 9

实验要求：

代码长度限制：16KB

时间限制：400ms

内存限制：64MB

思路（简单粗暴）：插入排序、堆排序每迭代一次就和题目给出的中间序列比较是否相等，相等的就是相应的排序，直接输出。

代码：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
void MaxHeapify(int Array[], int Start, int End) //判断大小并执行交换（调整堆）
{
    int DadNode = Start;
    int SonNode = DadNode * 2 + 1;
    while (SonNode <= End)   
    {    
        if (SonNode + 1 <= End && Array[SonNode] < Array[SonNode + 1])  
            ++SonNode;
        if (Array[DadNode] > Array[SonNode]) 
            return;
        else  
        {
            swap(Array[DadNode], Array[SonNode]);
            DadNode = SonNode; 
            SonNode = SonNode * 2 + 1;
        }
    }
    return;
}
bool IsEqual(int Array[], int Length, vector<int> Vector) //与中间序列是否相等
{
    vector<int> vector;
    for (int i = 0; i < Length; i++)
    {
        vector.push_back(Array[i]);
    }
    if (vector == Vector) return true;
    return false;
}
void HeapSort(int Array[], int Length, vector<int> Vector) 
{
    for (int i = Length / 2 - 1; i >= 0; --i) //建堆
        MaxHeapify(Array, i, Length - 1);
    for (int i = Length - 1; i > 0; --i) //排序
    {
        swap(Array[0], Array[i]);
        MaxHeapify(Array, 0, i - 1);
        if (IsEqual(Array, Length, Vector))
        {
            cout << "Heap Sort" << endl;
            swap(Array[0], Array[i - 1]);
            MaxHeapify(Array, 0, i - 2);
            for (int j = 0; j < Length; j++)
            {
                if (j) putchar(' ');
                cout << Array[j];
            }
            return;
        }
    }
    return;
}
bool InsertionSort(int Array[], int Length, vector<int> Vector)
{
    for (int i = 1; i < Length; i++)
    {
        for (int j = i; j > 0; j--)
        {
            if (Array[j - 1] > Array[j])
                swap(Array[j - 1], Array[j]);
        }
        if (IsEqual(Array, Length, Vector)) //i + 1再迭代一次（结果）
        {
            cout << "Insertion Sort" << endl;
            for (int j = i + 1; j > 0; j--)
            {
                if (Array[j - 1] > Array[j])
                    swap(Array[j - 1], Array[j]);
            }
            return true;
        }
    }
    return false;
}
int main()
{
    int Amout, Number; //Amount元素总数
    cin >> Amout;
    int Array1[Amout], Array2[Amout]; //初始序列
    vector<int> Compared; //中间序列
    for (int i = 0; i < Amout; i++)
    {
        cin >> Array1[i];
        Array2[i] = Array1[i];
    }
    for (int i = 0; i < Amout; i++)
    {
        cin >> Number;
        Compared.push_back(Number);
    }
    if (InsertionSort(Array1, Amout, Compared)) //先看插入排序能否得到中间序列，也可以先看堆排序，不影响
    {
        for (int i = 0; i < Amout; i++)
        {
            if (i) putchar(' ');
            cout << Array1[i];
        }
        return 0;
    }
    HeapSort(Array2, Amout, Compared);
    return 0;
}

结果：

堆排序算法参考：菜鸟教程-堆排序-C++