23.二叉搜索树的后序遍历序列

题目描述

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

python:

class Solution:
    def VerifySquenceOfBST(self, sequence):
        if len(sequence) == 0:
            return False
        elif len(sequence) == 1:
            return True
        else:
            # 左右子树是否符合条件
            left = True
            right = True
            root = sequence[-1]
            # 第一个比root大的节点，从temp开始到sequence - 1是树的右子树
            temp = -1
            for i in range(len(sequence) - 1):
                if sequence[i] > root:
                    temp = i
                    break
            # 说明存在右子树，当temp<0时，说明没有右子树
            if temp >= 0:
                # 判断右子树是否符合条件
                for j in range(temp, len(sequence) - 1):
                    if sequence[j] < root:
                        return False
            # 说明只有左子树
            if temp == -1:
                left = self.VerifySquenceOfBST(sequence[:-1])
            # 说明只有右子树
            elif temp == 0:
                right = self.VerifySquenceOfBST(sequence[:-1])
            else:
                left = self.VerifySquenceOfBST(sequence[:temp])
                right = self.VerifySquenceOfBST(sequence[temp:-1])
            return left and right

c++:

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size()==0){
            return false;
        }
        else if(sequence.size()==1){
            return true;
        }
        else{
            vector<int> leftTree, rightTree;
            bool left = true;
            bool right = true;
            int root = sequence[sequence.size()-1];
            int temp = -1;
            for(int i=0;i<sequence.size()-1;i++){
                if(sequence[i]>root){
                    temp = i;
                    break;
                }
            }
            // 当存在右子树时,如果右子树节点值小于根节点值,直接返回false
            if(temp>=0){
                for(int j=temp;j<sequence.size()-1;j++){
                    if(sequence[j]<root){
                        return false;
                    }
                }
            }
            // 说明只存在左子树
            if(temp==-1){
                for(int m=0;m<sequence.size()-1;m++){
                    leftTree.push_back(sequence[m]);
                }
                left = VerifySquenceOfBST(leftTree);
            }
            // 说明只存在右子树
            else if(temp==0){
                for(int m=0;m<sequence.size()-1;m++){
                    rightTree.push_back(sequence[m]);
                }
                right = VerifySquenceOfBST(rightTree);
            }
            else{
                for(int m=0;m<temp;m++){
                    leftTree.push_back(sequence[m]);
                }
                for(int m=temp;m<sequence.size()-1;m++){
                    rightTree.push_back(sequence[m]);
                }
                left = VerifySquenceOfBST(leftTree);
                right = VerifySquenceOfBST(rightTree);
            }
            return left && right;
        }
    }
};