剑指offer-刷题笔记-中难题-JZ33 二叉搜索树的后序遍历序列

剑指offer-刷题笔记-中难题-JZ33 二叉搜索树的后序遍历序列

版本1-本来打算用递归的方法，没有完整的写出来

class Solution {
public:
    
    
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size() == 0)
        {
            return false;
        }else{
            //根节点
            int root = sequence[sequence.size()-1];
            int leftRoot;
            int rightRoot;
            bool flagRight = false;
            bool flagLeft = false;
            for(int j = sequence.size()-2;j >= 0;j--)
            {
                //第一个大于 right
                if(sequence[j] > root && flagRight == false)
                {
                    rightRoot = sequence[j];
                    flagRight = true;
                }
                
                //第一个小于 left 
                if(sequence[j] < root && flagLeft == false)
                {
                    leftRoot = sequence[j];
                    flagLeft = true;
                }
            }
            
            
        }      
        return false;
    }
};

版本2-递归

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size() == 0) return false;
        //sequence.size() - 1 对应整体的根节点
        return order(sequence, 0, sequence.size() - 1);
    }
    bool order(vector<int>& sequence, int l, int r) {
        // 剩一个节点的时候 返回 true
        if(l >= r) return true;
        int j;
        int mid = sequence[r];
        
        // 找到左子树和右子树的分界点，j代表左子树的最后一个索引位置
        //左子树和右子树的分界点就是左子树的根节点，也就是从后向前第一个小于整体根节点的值
        for(j = r; j >= l; j--) {
            int cur = sequence[j];
            if(cur < mid) break;
        }
        
        // 判断所谓的左子树中是否又不合法（不符合二叉搜索树）的元素
        //遍历左子树，左子树中元素应该都小于整体根
        for(int i = j; i >= l; i--) {
            int cur = sequence[i];
            if(cur > mid) return false;
        }
        return order(sequence, l, j) && order(sequence, j+1, r-1);
    }
};

版本3-辅助栈

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size() == 0)
        {
            return false;
        }
        int root = INT_MAX;
        stack<int> s;
        //反向遍历
        for(int j = sequence.size()-1;j>=0;j--)
        {
            if(sequence[j] > root) return false;
            
            while( !s.empty() && sequence[j] < s.top())//注意!s.empty()写在前，先判空
            {
                root = s.top();
                s.pop();
            }
            s.push(sequence[j]);
        }
        return true;
    }
};