PAT 1098. Insertion or Heap Sort (25)

题目地址： http://www.patest.cn/contests/pat-a-practise/1098

本来试图复习一下c++的继承，  无奈都忘光了， static 成员， 抽象类， 纯虛函数。。。。

c++语法都忘光了， 一个语句： A a = new A();  竟然编译不过， 必须用指针接， 哎， A *a = new A();  接近一年没写c++, 都还给老师了

对于c++的两种声明对象：

A a; //在栈上分配空间

A *a = new A(); //在堆上

下面的代码我好像忘了写析构函数

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>

using namespace std;
/*
试图用使用继承， 抽象函数搞不定阿
struct Sortor
{
    string name;
    int length;
    int iter;
    int *arr;

    Sortor(int *a, int n):arr(a),length(n),iter(n)
    {

    }
    virtual void start() = 0;
    virtual bool has_next() = 0;
    virtual void next_iteration() = 0;
};
*/


const int MAXN = 200;
int nums[MAXN];
int part_sorted_nums[MAXN];
int n;

struct HeapSortor//: public Sortor
{
    string name;
    int length;
    int iter;
    int arr[MAXN];
    HeapSortor(int *a, int len):length(len),iter(len),
    name("Heap Sort")
    {
        /*这个函数也不会用了， 真坑*/
        //memcpy(arr + 1, a + 1, len);
        for (int i = 1; i <= len; ++i)
            arr[i] = a[i];
    }

    int parent(int i)
    {
        return i >> 1;
    }

    int left(int i)
    {
        return i << 1;
    }

    int right(int i)
    {
        return i << 1 | 1;
    }

    void maintain(int i, int len)
    {
        int l = left(i);
        int r = right(i);
        int largest = i;
        if (l <= len && arr[l] > arr[i]) largest = l;
        if (r <= len && arr[r] > arr[largest]) largest = r;

        if (largest != i)
        {
            swap(arr[i], arr[largest]);
            maintain(largest, len);
        }
    }

    void build_max_heap()
    {
        for (int i = (length >> 1); i > 0; --i)
        {
            maintain(i, length);
        }
    }

    bool has_next()
    {
        return iter > 1;
    }

    void next_iteration()
    {
        swap(arr[1], arr[iter]);
        maintain(1, --iter);
    }

    void start()
    {
        build_max_heap();
        iter = length;
    }
};

struct InsertionSort
{
    string name;
    int length;
    int iter;
    int arr[MAXN];
    InsertionSort(int *a, int len):length(len),iter(0),
    name("Insertion Sort")
    {
       // memcpy(arr + 1, a + 1, len);
        for (int i = 1; i <= len; ++i)
            arr[i] = a[i];
    }

    void start()
    {
        iter = 2;
    }

    bool has_next()
    {
        return iter <= length;
    }

    void next_iteration()
    {
        int key = arr[iter];
        int i = iter - 1;
        while (i > 0 && arr[i] > key)
        {
            arr[i + 1] = arr[i];
            --i;
        }
        arr[i + 1] = key;
        ++iter;
    }
};


bool check(int *a, int *b, int len)
{
    for (int i = 1; i <= n; ++i)
    {
        if (a[i] != b[i])
            return false;
    }
    return true;
}

void print(int *arr, int n)
{
    for (int i = 1; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    cout << arr[n] << endl;
}

/*下面两个check函数本可以利用多态合并成一个， 无奈c++语法，继承的东西早忘光了*/
bool check_heap_sort()
{
    HeapSortor sortor(nums, n);
    sortor.start();
    while(sortor.has_next())
    {
        sortor.next_iteration();
        if (check(sortor.arr, part_sorted_nums, n))
        {
            cout << "Heap Sort" << endl;
            if (sortor.has_next())
                sortor.next_iteration();
            print(sortor.arr, n);
            return true;
        }
    }
    return false;
}

bool check_insertion_sort()
{
    InsertionSort sortor(nums, n);
    sortor.start();
    while(sortor.has_next())
    {
        sortor.next_iteration();
        if (check(sortor.arr, part_sorted_nums, n))
        {
            cout << "Insertion Sort" << endl;
            if (sortor.has_next())
                sortor.next_iteration();
            print(sortor.arr, n);
            return true;
        }
    }
    return false;
}

int main()
{
    while(cin >> n)
    {
        for (int i = 1; i <= n; ++i)
            cin >> nums[i];
        for (int i = 1; i <= n; ++i)
            cin >> part_sorted_nums[i];
        if (!check_heap_sort())
            check_insertion_sort();
    }
    return 0;
}