PAT A 1155 Heap Paths (30 分) 堆

    题目大意：对于给定的完全二叉树，判断是否是最大堆或是最小堆， 在输出每个叶子节点到根节点的路径，要求要按照叶子节点从右往左的顺序输出。

    为了方便起见我是从数组下标0位置开始存储的，这样父节点的下标为 i 时，左孩子的下标是 2*i + 1, 右孩子的下标是 2*i + 2， 下标最大的非叶子节点 的下标是(n - 1 - 1) / 2， 其中 n 是总节点数。

    判断最大最小堆很简单，就是从下标最大的非叶子节点一直数到根节点(下标为0)，判断它们和左右孩子的大小关系即可，问题主要在按照叶子节点从右往左的顺序输出路径这个要求上。

   首先，如果已知一个叶子节点的下标k，输出路径是很简单的，它的父节点是 (k-1) / 2， 这样一直遍历到0， 再逆序输出就好了。问题关键在于决定叶子节点的顺序，我这里用了层数这个信息来辅助判断。

   如图所示的测试用例。根据节点数 n 可以计算出以下的信息：

    总层数 layer、 下标最小的叶子节点 smallestLeaf = (n - 1 - 1) / 2 + 1; 下标最大的叶子节点就是 n - 1 了。然后根据二叉树是否是满树来判断最右边的节点下标。

    如果是满树（2^layer - 1 == n)，那么最右边的叶子节点就是n -1， 直接按照 n-1 到 smallestLeaf 的顺序输出路径就可以了。

    但如果不是满树，那么分两种情况：

    情况1：就是测试用例中的情形，最右和最左的叶子节点不在同一层，最左边的叶子节点应当是 mostLeft = 2^(layer - 1) - 1, 而最右边的叶子节点是 mostRight = mostLeft -1; 于是要按照 [mostRight, smallestLeaf] 的顺序先输出， 再输出 [n-1, mostLeft] 的叶子节点。

    情况2：最右边和最左的叶子节点在同一层，直接输出[n-1, smallestLeaf]。事实上这个可以合并到情况1中， 相当于mostLeft == smallestLeaf。

    AC代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;

bool isMaxHeap(vector<int> &v)
{
    for (int i = 0; i <= (v.size() -1 - 1) / 2; ++i)
    {
        if(v[i] < v[2*i+1]) return false;
        if(2 * i + 2 < v.size() && v[i] < v[2*i+2]) return false;
    }
    return true;
}

bool isMinHeap(vector<int> &v)
{
    for (int i = 0; i <= (v.size() - 1- 1) / 2; ++i)
    {
        if(v[i] > v[2*i+1]) return false;
        if(2*i+2 < v.size() && v[i] > v[2*i+2]) return false;
    }
    return true;
}

void printPath(vector<int> &v, int leaf)
{
    int parent = leaf;
    vector<int> path;
    while(parent != 0)
    {
        path.push_back(v[parent]);
        parent = (parent - 1) / 2;
    }
    path.push_back(v[0]);
    for (int i = path.size() - 1; i >= 0; --i)
    {
        printf("%d", path[i]);
        if(i > 0) printf(" ");
        else printf("\n");
    }
}

int main()
{
    int N;
    cin >> N;
    vector<int> v(N);
    for (int i = 0; i < N; ++i)
    {
        scanf("%d", &v[i]);
    }
    int layer = 1;
    while(pow(2, layer) - 1 < N) layer++;
    int smallestLeaf = (N - 1 - 1) / 2 + 1;
    if(N == pow(2, layer) - 1)
    {
        for (int i = N - 1; i >= smallestLeaf; --i)
        {
            printPath(v, i);
        }
    }
    else
    {
        int mostLeft = pow(2, layer-1) - 1;
        int mostRight = mostLeft - 1;
        for (int i = mostRight; i >= smallestLeaf; --i)
        {
            printPath(v, i);
        }
        for (int i = N - 1; i >= mostLeft ; --i)
        {
            printPath(v, i);
        }
    }
    if(isMaxHeap(v)) printf("Max Heap\n");
    else if(isMinHeap(v)) printf("Min Heap\n");
    else printf("Not Heap");
    return 0;
}