【剑指offer】23.二叉搜索树的后序遍历序列

总目录：

算法之旅导航目录

 

1.问题描述

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

数据范围： 节点数量 0≤n≤1000 ，节点上的值满足 1≤val≤10^5，保证节点上的值各不相同
要求：空间复杂度 O(n)，时间时间复杂度 O(n^2)

提示：

1.二叉搜索树是指父亲节点大于左子树中的全部节点，但是小于右子树中的全部节点的树。

2.该题我们约定空树不是二叉搜索树

3.后序遍历是指按照 “左子树-右子树-根节点” 的顺序遍历

4.二叉搜索树不是满树，除根节点外可以任意空缺子节点；

 

2.问题分析

 1递归，注意各种边界条件

3.代码实例

递归

class Solution {
  public:
    bool IsBST(vector<int> sequence) {
        int sequenceSize = sequence.size();

        //中止条件
        //小于等于一个节点
        if (sequenceSize <= 1) {
            return true;
        }

        //寻找左右子树分割点
        int rootVal = sequence[sequenceSize - 1];
        int rightRootId = sequenceSize - 1;//最大到根节点处
        for (int i = 0; i < sequenceSize; i++) {
            if (sequence[i] > rootVal) {
                rightRootId = i;
                break;
            }
        }
        //切割子树
        vector<int> leftVec, rightVec;
        for (int i = 0; i < rightRootId; i++) {
            leftVec.push_back(sequence[i]);
        }
        for (int i = rightRootId; i < sequenceSize - 1; i++) {
            rightVec.push_back(sequence[i]);
        }

        //检查根、左右子节点的大小关系
        int leftSize = leftVec.size();
        if (leftSize >= 1) {
            for (int i = 0; i < leftSize; i++) {
                if (leftVec[i] >= rootVal) {
                    return false;
                }
            }
        }
        bool isLeftBe = IsBST(leftVec);

        int rightSize = rightVec.size();
        if (rightSize >= 1) {
            for (int i = 0; i < rightSize; i++) {
                if (rightVec[i] <= rootVal) {
                    return false;
                }
            }
        }
        bool isRightBe = IsBST(rightVec);

        //递归调用
        return  isLeftBe && isRightBe;
    }

    bool VerifySquenceOfBST(vector<int> sequence) {
        int sequenceSize = sequence.size();

        //中止条件
        //空树不是搜索树
        if (sequenceSize <= 0) {
            return false;
        }

        //递归调用
        return IsBST(sequence);
    }
};

 优雅的递归，不要那么多vector操作

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int n = sequence.size();
        if(n == 0) return false;    // 注意审题, 约定空树不是二叉搜索树
        return check(sequence, 0, n - 1);
    }

    bool check(vector<int>& sequence, int l, int r){
        if(l >= r) return true;    // 若当前子树只有一个节点

        int root = sequence[r];    // 当前子树的根节点

        // 划分出右子树
        int j = r - 1;
        while(j >= 0 && sequence[j] > root) j--;

        // 检查左子树是不是存在大于根节点的数
        for(int i = l; i <= j; i++){
            if(sequence[i] > root) return false;
        }

        // 分治法检查左子树和右子树
        return check(sequence, l, j) && check(sequence, j + 1, r - 1);
    }
};