PAT(Advanced)1147 Heaps （C++實現）

PAT(Advanced)1147 Heaps （C++實現）

題目鏈接

1147 Heaps

題目大意

給定各不相同的非負整數層序遍歷序列，判斷該序列是否爲堆結構，若是最大堆則輸出Max Heap，若是最小堆則輸出Min Heap，若不滿足堆結構則輸出Not Heap，下一行輸出後序遍歷序列

算法思路

根據堆的定義，左右子樹的關鍵字小於根節點的二叉樹爲最大堆，反之則爲最小堆，遞歸地判斷當前子樹是否滿足堆性質、當前子樹的左右子樹是否滿足堆性質，葉子節點直接返回true，遞歸結束後即可得到結果，先判斷是否爲最大堆，然後判斷是否爲最小堆，最後輸出後序遍歷序列

AC代碼

/*
author : eclipse
email  : [email protected]
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

最後

• 由於博主水平有限，不免有疏漏之處，歡迎讀者隨時批評指正，以免造成不必要的誤解！