牛客刷题二叉树之重建二叉树 and 二叉搜索树的后序遍历序列

题目描述一重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

牛客链接：

https://www.nowcoder.com/practice/8a19cbe657394eeaac2f6ea9b0f6fcf6?tpId=13&&tqId=11157&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

解题思路：

因为是树的结构，一般都是用递归来实现。
用数学归纳法的思想就是，假设最后一步，就是root的左右子树都已经重建好了，那么我只要考虑将root的左右子树安上去即可。
根据前序遍历的性质，第一个元素必然就是root，那么下面的工作就是如何确定root的左右子树的范围。
根据中序遍历的性质，root元素前面都是root的左子树，后面都是root的右子树。那么我们只要找到中序遍历中root的位置，就可以确定好左右子树的范围。
正如上面所说，只需要将确定的左右子树安到root上即可。递归要注意出口，假设最后只有一个元素了，那么就要返回。

代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if(pre.size()==0 || pre.size()!=vin.size()) return NULL;
        int len = pre.size();
        int count = 0;
        for(int i=0; i<len; i++) {
            if (vin[i] == pre[0]) {
                count = i;
                break;
            }
        }
        TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
        root->val = pre[0];
        root->left = reConstructBinaryTreeCore(pre, vin, 1, count, 0, count-1);
        root->right = reConstructBinaryTreeCore(pre, vin, count+1, len-1, count+1, len-1);
        return root;
    }
    
    TreeNode* reConstructBinaryTreeCore(vector<int> pre,vector<int> vin, int preBegin, 
                                        int preEnd, int vinBegin, int vinEnd) {
        if(preBegin > preEnd) return NULL;
        TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
        root->val = pre[preBegin];
        if(preBegin == preEnd) {
            root->left = NULL;
            root->right = NULL;
            return root;
        }
        int length = 0;
        for(int i=vinBegin; i<=vinEnd; i++) {
            if(vin[i] == pre[preBegin]) {
                length = i-vinBegin;
                break;
            }
        }
        if(length > 0) {
            root->left = reConstructBinaryTreeCore(pre, vin, preBegin+1, preBegin+length, vinBegin, vinBegin+length-1);
        } else {
            root->left = NULL;
        }
        
        if(vinBegin+length < vinEnd) {
            root->right = reConstructBinaryTreeCore(pre, vin, preBegin+length+1, preEnd, vinBegin+length+1, vinEnd);
        } else {
            root->right = NULL;
        }
        
        return root;
    }
};

题目描述二二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。

牛客链接：

https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&&tqId=11176&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

代码

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int len = sequence.size();
        if(len == 0) return false;
        return isPostOrder(sequence, 0, len-1);
    }
    bool isPostOrder(vector<int> sequence, int begin, int end) {
        if(begin >= end) return true;
        int count = begin;
        bool flag = true;
        int i = begin;
        for(; i<end; i++) {
            if(sequence[i] > sequence[end]) {
                break;
            }
        }
        count = i;
        for(; i<end; i++) {
            if(sequence[i] < sequence[end]) {
                flag = false;
                return flag;
            }
        }
        bool leftFlag = isPostOrder(sequence, begin, count-1);
        bool rightFlag = isPostOrder(sequence, count, end-1);
        return flag && leftFlag && rightFlag;
    }
};

注意：
二叉树