二叉搜索树的后序遍历序列 ---- newcoder

题目描述

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

newcoder 题目链接

题解

---

以下为 2019.06.08 更新

class Solution {
public:
    bool VerifySquenceOfBST(vector<int>& sequence) {
        
        // 要说一颗空树是搜索二叉，好像也没毛病哦
        // 但是nowcoder不一样，空树不算搜索二叉
        // 如果这里返回 true  测试用例只能通过 87.50%
        if (sequence.empty())
        {
            return false;
        }
        
        return assist(sequence, 0, static_cast<int>(sequence.size()));
    }
private:
    bool assist(std::vector<int>& array, int left, int right);
};

bool Solution::assist(std::vector<int>& array, int left, int right)
{
    // 递归出口 区间只有一个元素 或者 区间内没有元素
    if (left+1 == right || left >= right)
    {
        return true;
    }
    
    // 之后就要考虑怎么划分区间来递归了
    /**
     * 对搜索二叉的后续遍历来说，序列最右侧的元素肯定是这颗搜索二叉的根节点
     * 我们从左到右遍历序列，第一个比最右侧元素大的元素，必定是当前根节点右子树的根节点
     * 以此来将序列划分为两个部分
     * 之后再判断这两个部分是否满足搜索二叉的性质
     * 根节点将序列分为两个部分 左子树的所有元素都小于根节点 右子树的所有元素都大于根节点
     */
    int pos = left;
    // 从左往右找第一个比 最右边元素 大的元素
    for (pos = left; pos < right-1; ++pos)
    {
        if (array[pos] > array[right-1])
        { // 找到位置
            break;
        }
    }
    
    // // 如果这个条件成立，搜索二叉已退化为左单只树
    // // 这并不能判断这是左单只，只能说明 初步判断左子树序列没有问题
    // // 至于是不是有问题，需要进一步判断，比如 4 2 1 3 
    // if (pos == right)
    // {
    //     return true;
    // }

   
    // 判断右子树
    for (int i = pos; i < right-1; ++i)
    {
        if (array[i] <= array[right-1])
        {
            return false;
        }
    }
    
    // 之后进行递归
    return assist(array, left, pos) && assist(array, pos, right-1);
}

---

以上为 2019.06.08 更新

首先我们先回忆一下二叉搜索树，
对二叉搜索树的根节点，根节点的左子树上所有元素的值都比根节点的值小，根节点右子树上所有元素的值都比根节点元素的值大
在回忆一下后序遍历
后序遍历序列的最后一个元素一定是根节点，再结合二叉搜索树的特性，根节点会把这个序列分为两部分，
好，解决这道题的办法是递归
具体怎么做？
拿到序列，取序列最后一个元素，然后从前往后遍历序列
遇到比最后一个元素大的停下，记录位置，继续往后走，如果有比根节点小的，不用继续了，直接返回 false(为啥？自己考虑二叉搜索的特性) ，刚刚已经记录了分割的位置，递归解决

附上代码：

class Solution {
public:
    bool VerifySquenceOfBST(std::vector<int> sequence) {
        // 二叉搜索树的后序序列的合法序列是，
        // 对于一个序列S，最后一个元素是x （也就是根），
        // 如果去掉最后一个元素的序列为T，那么T满足：
        // T可以分成两段，前一段（左子树）小于x，后一段（右子树）大于x，
        // 且这两段（子树）都是合法的后序序列。
        // 完美的递归定义
        if(sequence.size() == 0)
        {
            return false;
        }

        return judge(sequence, 0, sequence.size());
    }
private:
    bool judge(std::vector<int> &v, int left, int right)
    {
        // 如果区间内只有一个元素或者没有元素，直接返回 true
        if(left+1 >= right)
        {
            return true;
        }
        // 从左到右找到第一个大于最后一个元素的位置
        int last = v[right - 1];
        int i = left;
        for(i = left; i < right - 1; ++i)
        {
            if(v[i] > last)
            {
                break;
            }
        }
        for(int j = i; j < right; ++j)
        {
            if(v[j] < last)
            {
                return false;
            }
        }
        
        return judge(v, left, i) && judge(v, i, right - 1);
    }
};

成功通过 newcoder 所有测试用例

---

有问题欢迎留言，大家一起讨论
有更好的方法还请不吝赐教
谢谢你的浏览 ?