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

本文链接：https://blog.youkuaiyun.com/cmdxly/article/details/124606899

该博客探讨了三种不同的算法实现来验证给定的整数序列是否为二叉搜索树的后序遍历结果。分别使用了递归、递归辅助函数和辅助栈的方法进行详细解释和代码展示。每个版本的代码都注重寻找左子树和右子树的边界，并确保序列符合二叉搜索树的性质。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

剑指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;
    }
};