PAT(Advanced)1043 Is It a Binary Search Tree C++實現

PAT(Advanced)甲級1043 Is It a Binary Search Tree C++實現

題目鏈接

PAT(Advanced)1043 Is It a Binary Search Tree

題目大意

給定整數序列，判斷是否是二叉搜索樹的前序遍歷序列或者二叉搜索樹的鏡像的前序遍歷序列，若是輸出“YES”，並輸出二叉搜索樹或二叉搜索樹鏡像的後續遍歷序列，二叉搜索樹的鏡像即爲將二叉搜索樹的左右子樹交換，遞歸地，左右子樹的左右子樹也必須交換。

算法思路

利用給定的整數序列，構建二叉搜索樹，先序遍歷判斷是否與給定序列一致，若一致則返回true，否則將二叉搜索樹左右子樹交換，再次先序遍歷判斷是否與給定序列一致，若一致返回true，否則返回false，遞歸地進行先序遍歷，對於當前子樹，子樹當前結點關鍵字與給定序列對應的關鍵字一致，左右子樹中所有關鍵字必須滿足條件，才返回true，即return (p->val == sequence[number++]) && preOrderTraverse(p->left) && preOrderTraverse(p->right);

AC代碼

/*
author : eclipse
email  : [email protected]
time   : Sun Jun 21 11:09:17 2020
*/
#include <bits/stdc++.h>
using namespace std;

struct Node {
    int val;
    Node *left;
    Node *right;
    Node(int data) : val(data), left(NULL), right(NULL) {}
};

class BST {
private:
    vector<int> sequence;
    vector<int> postOrderSequence;
    Node *root;
    int number;
    bool preOrderTraverse(Node *p);
    void inOrderInverse(Node *p);
    void postOrderTraverse(Node *p);
public:
    BST(vector<int> v);
    void insert(Node* &p, int data);
    bool isBST();
    void postOrderTraverse();
    void printPostOrderSequence();
};

BST::BST(vector<int> v) {
    sequence.insert(sequence.begin(), v.begin(), v.end());
    root = NULL;
    number = 0;
    for (int i = 0; i < sequence.size(); i++) {
        insert(root, sequence[i]);
    }
}

void BST::insert(Node* &p, int data) {
    if (p == NULL) {
        p = new Node(data);
        return;
    }

    if (data < p->val) {
        insert(p->left, data);
    } else {
        insert(p->right, data);
    }
}

bool BST::isBST() {
    if (preOrderTraverse(root)) {
        return true;
    } else {
        number = 0;
        inOrderInverse(root);
        return preOrderTraverse(root);
    }
}

bool BST::preOrderTraverse(Node *p) {
    if (!p) {
        return true;
    }
    return (p->val == sequence[number++]) && preOrderTraverse(p->left) && preOrderTraverse(p->right);
}

void BST::inOrderInverse(Node *p) {
    if (!p) {
        return;
    }
    swap(p->left, p->right);
    inOrderInverse(p->left);
    inOrderInverse(p->right);
}

void BST::postOrderTraverse(Node *p) {
    if (!p) {
        return;
    }
    postOrderTraverse(p->left);
    postOrderTraverse(p->right);
    postOrderSequence.push_back(p->val);
}

void BST::printPostOrderSequence() {
    for (int i = 0; i < postOrderSequence.size(); i++) {
        if (i != postOrderSequence.size() - 1) {
            printf("%d ", postOrderSequence[i]);
        } else {
            printf("%d", postOrderSequence[i]);
        }
    }
}

void BST::postOrderTraverse() {
    postOrderTraverse(root);
}

int main(int argc, char const *argv[]) {
    int N;
    scanf("%d", &N);
    vector<int> v;
    for (int i = 0; i < N; i++) {
        int value;
        scanf("%d", &value);
        v.push_back(value);
    }
    BST *bst = new BST(v);
    if (bst->isBST()) {
        printf("YES\n");
        bst->postOrderTraverse();
        bst->printPostOrderSequence();
    } else {
        printf("NO");
    }
    return 0;
}

樣例輸入1

7
8 6 5 7 10 8 11

樣例輸出1

YES
5 7 6 8 11 10 8

樣例輸入2

7
8 10 11 8 6 7 5

樣例輸出2

YES
11 8 10 7 5 6 8

樣例輸入3

7
8 6 8 5 10 9 11

樣例輸出3

NO

鳴謝

PAT

最後

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