剑指offer23：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。输出Yes OR No。

　　

1 题目描述

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

2 思路和方法

　　二叉搜索树：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

　　递归求解：

（1）从第0位开始，找到第一位比根节点大的元素，记录此位置i。在此位置之前都属于左子树（此时已经断定左子树都小于根节点）

（2）检查右子树是否都大于跟节点（从第i位开始，到根节点前）

（3）判断左右子树是否都属于二叉搜索树。

二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低，为O(log n)。二叉查找树是基础性数据结构，用于构建更为抽象的数据结构，如集合、multiset、关联数组等。

非递归求解：

      　6
      /      
    3         8
  /        /  
2     5    7    9

2 5 3 7 9 8 6

　　左子树一定比右子树小，因此去掉根结点后，数字分为left，right两部分，right部分的最后一个数字是右子树的根，且它比左子树所有结点的值大，因此我们可以每次只看有子树是否符合条件即可，即使到达了左子树，左子树也可以看出由左右子树组成的树还像右子树那样处理.

3 C++核心代码

3.1 递归求解

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {}    //判断某数组是不是二叉搜索树的后序遍历序列
        if(sequence.empty())
            return false;
        int index;
        int begin = 0;
        int end = sequence.size()-1;
        int root = sequence[end];    
        for(index = begin;index<end;index++)    //左子结点小于根节点
            if(sequence[index]>root)
                break;
        for(int j = index;index<end;index++)    //右子结点大于根结点
            if(sequence[index]<root)
                return false;
        bool left = true;
        vector<int> left_sq(sequence.begin(),sequence.begin()+index);
        if(index>begin)
            left = VerifySquenceOfBST(left_sq);    //判断左子树是不是二叉搜索树
        bool right = true;
        vector<int> right_sq(sequence.begin()+index+1,sequence.end());
        if(index<end-1)
            right = VerifySquenceOfBST(right_sq);    //判断右子树是不是二叉搜索树
        return left&&right;
    }
};

3.2 非递归求解

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {    //判断某数组是不是二叉搜索树的后序遍历序列
        int backIdx = sequence.size();
        if(backIdx==0) return false;

        int forIdx = 0;
        while(--backIdx)  // backIdx=1时退出循环
        {
            while(sequence[forIdx]<sequence[backIdx])  forIdx++;     // forIdx从前往后扫描left部分
            while(sequence[forIdx]>sequence[backIdx])  forIdx++;     // forIdx从前往后继续扫描，主要扫right部分

            if(forIdx<backIdx) return false;    // 如果原序列是二叉搜索树BST的后序遍历序列，则终止时forIdx=backIdx
            forIdx=0;                           // 将forIdx拉回序列起点继续扫
        }
        return true;
    }
};

4 C++完整代码

#include<cstdio>
#include<vector>

using namespace std;

class Solution{
public:
    bool VerifySquenceOfBST(vector<int> sequence)
    {
        int len = sequence.size();
        if (len <= 0) 
            return false;
        vector<int> left, right;
        int root = sequence[len - 1];
        int i = 0;
        while (i<len - 1)  // 处理left部分 
        {
            if (sequence[i]>root) 
                break;
            left.push_back(sequence[i]);
            i++;
        }
        int j = i; // 处理right部分，此时i为left部分最后一个结点的下标 
        while (j<len - 1)
        {
            if (sequence[j]<root) 
                return false;
            right.push_back(sequence[j]);
            j++;
        }
        bool bleft = true; // 应初始化为true，left部分是BST序列，才能调用VerifySquenceOfBST()    
        if (i != 0) 
            bleft = VerifySquenceOfBST(left); // i为left部分最后一个结点的下标 ，i!=0表示有左子树 
        bool bright = true;
        if (i != len - 1) 
            bright = VerifySquenceOfBST(right);  // i!= len-1表示有右子树
        return (bleft && bright);
    }
};
// 以下为测试部分 
int main()
{
    Solution sol;
    vector<int> vec1 = { 2, 5, 3, 7, 9, 8, 6 };
    vector<int> vec2 = { 5, 7, 6, 9, 11, 10, 8 };
    vector<int> vec3 = { 7, 4, 6, 5 };
    bool res1 = sol.VerifySquenceOfBST(vec1);
    bool res2 = sol.VerifySquenceOfBST(vec2);
    bool res3 = sol.VerifySquenceOfBST(vec3);

    printf("%d
", res1);
    printf("%d
", res2);
    printf("%d
", res3);

    system("pause");
    return 0;
}

参考资料

https://blog.csdn.net/cdatreides/article/details/81701523

https://blog.csdn.net/lzuacm/article/details/51317617