PAT(Advanced)1147 Heaps （C++实现）

PAT(Advanced)1147 Heaps （C++实现）

题目链接

1147 Heaps

题目大意

给定各不相同的非负整数层序遍历序列，判断该序列是否为堆结构，若是最大堆则输出Max Heap，若是最小堆则输出Min Heap，若不满足堆结构则输出Not Heap，下一行输出后序遍历序列

算法思路

根据堆的定义，左右子树的关键字小于根节点的二叉树为最大堆，反之则为最小堆，递归地判断当前子树是否满足堆性质、当前子树的左右子树是否满足堆性质，叶子节点直接返回true，递归结束后即可得到结果，先判断是否为最大堆，然后判断是否为最小堆，最后输出后序遍历序列

AC代码

/*
author : eclipse
email  : eclipsecs@qq.com
time   : Sun Jun 21 21:59:15 2020
*/
#include <bits/stdc++.h>
using namespace std;

class Heap {
private:
    vector<int> sequence;
    vector<int> postOrderSequence;
    bool isMaxHeap(int p);
    bool isMinHeap(int p);
    void postOrderTraverse(int p);
public:
    Heap() {};
    void isHeap(vector<int> v);
    void printPostOrder();
};

void Heap::isHeap(vector<int> v) {
    sequence.clear();
    sequence.push_back(0);
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        sequence.push_back(*it);
    }
    if (isMaxHeap(1)) {
        printf("Max Heap\n");
    } else if (isMinHeap(1)) {
        printf("Min Heap\n");
    } else {
        printf("Not Heap\n");
    }
}

bool Heap::isMaxHeap(int p) {
    if (p >= sequence.size()) {
        return true;
    }
    int left = 2 * p;
    int right = 2 * p + 1;
    if (left < sequence.size() && right < sequence.size()) {
        return sequence[p] > sequence[left] && sequence[p] > sequence[right] && isMaxHeap(left) && isMaxHeap(right);
    } else if (left < sequence.size()) {
        return sequence[p] > sequence[left] && isMaxHeap(left);
    } else if (right < sequence.size()) {
        return sequence[p] > sequence[right] && isMaxHeap(right);
    } else {
        return true;
    }
}

bool Heap::isMinHeap(int p) {
    if (p >= sequence.size()) {
        return true;
    }
    int left = 2 * p;
    int right = 2 * p + 1;
    if (left < sequence.size() && right < sequence.size()) {
        return sequence[p] < sequence[left] && sequence[p] < sequence[right] && isMinHeap(left) && isMinHeap(right);
    } else if (left < sequence.size()) {
        return sequence[p] < sequence[left] && isMinHeap(left);
    } else if (right < sequence.size()) {
        return sequence[p] < sequence[right] && isMinHeap(right);
    } else {
        return true;
    }
}

void Heap::printPostOrder() {
    postOrderSequence.clear();
    postOrderTraverse(1);
    vector<int>::iterator it = postOrderSequence.begin();
    printf("%d", *it);
    while (++it != postOrderSequence.end()) {
        printf(" %d", *it);
    }
    printf("\n");
}

void Heap::postOrderTraverse(int p) {
    if (p >= sequence.size()) {
        return;
    }
    int left = 2 * p;
    postOrderTraverse(left);
    int right = 2 * p + 1;
    postOrderTraverse(right);
    postOrderSequence.push_back(sequence[p]);
}

int main(int argc, char const *argv[]) {
    int M, N;
    Heap *heap = new Heap();
    scanf("%d%d", &M, &N);
    for (int i = 0; i < M; i++) {
        vector<int> v;
        for (int j = 0; j < N; j++) {
            int value;
            scanf("%d", &value);
            v.push_back(value);
        }
        heap->isHeap(v);
        heap->printPostOrder();
    }
    return 0;
}

样例输入

3 8
98 72 86 60 65 12 23 50
8 38 25 58 52 82 70 60
10 28 15 12 34 9 8 56

样例输出

Max Heap
50 60 65 72 12 23 86 98
Min Heap
60 58 52 38 82 70 25 8
Not Heap
56 12 34 28 9 8 15 10

鸣谢

PAT

最后

• 由于博主水平有限，不免有疏漏之处，欢迎读者随时批评指正，以免造成不必要的误解！