牛客网－Ｃ++剑指offer－第二十三题(二叉搜索树的后序遍历序列)

题目描述

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

 

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

 

解题思路:

　　后序遍历的最后一个元素为根节点，将根节点与前面的元素进行比较，分出左侧二叉子树和右侧二叉子树分别进行存储，直到分完为止，然后将左右侧的元素个数之和与原来序列的总个数减一相比，不相等的话，说明不是二叉搜索树。因为空树不属于二叉搜索树，所以我们提前什么一个变量flag设置为true，如果数组为空了，那么就不需要遍历了，如果不为空，那么更新flag，左右数组都这样做，这样可以避免结束条件误判，如果不想这么写，那么直接建一个新函数即可（像参考代码2一样写，思路一样）。

 

参考答案:

#include <iostream>
#include <string.h>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <stack>
#include <queue>

using namespace std;

class Solution{
public:
    bool VerifySquenceOfBST(vector<int> sequence)
    {
        if (sequence.empty())
            return false;

        vector<int> left_sequence;
        vector<int> right_sequence;

        int root = sequence[sequence.size()-1];
        int left_flag = 0;
        int right_flag = 0;

        for (int i = 0; i < sequence.size()-1; ++i) {

            if (sequence[i] < root)
            {
                left_flag++;
                left_sequence.push_back(sequence[i]);
            }
            else
                break;
        }

        for (int j = left_flag; j < sequence.size()-1; ++j) {
            if (sequence[j] > root)
            {
                right_flag++;
                right_sequence.push_back(sequence[j]);
            }
        }

        if ((left_flag+right_flag) != (sequence.size()-1))
            return false;

        bool l_flag = true;
        if (!left_sequence.empty())
            l_flag = VerifySquenceOfBST(left_sequence);

        bool r_flag = true;
        if (!right_sequence.empty())
            r_flag = VerifySquenceOfBST(right_sequence);
        return (l_flag && r_flag);
    }

};

int main()
{
    vector<int> my_res;
    Solution solution;

    for (int i = 1; i < 16; ++i) {
        my_res.push_back(i);
    }

    if (solution.VerifySquenceOfBST(my_res))
    {
        cout<<"true"<<endl;
    } else{
        cout<<"false"<<endl;
    }

    return 0;
}

参考代码2：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.empty())
            return false;
        
        return verifySquence(sequence);
    }
    bool verifySquence(vector<int> sequence)
    {
        if(sequence.empty())
            return true;
        
        vector<int> left;
        vector<int> right;
        
        int i = 0;
        for(; i < sequence.size()-1; i++)
        {
            if(sequence[i] < sequence[sequence.size()-1])
                left.push_back(sequence[i]);
            else
                break;
        }
        
        for(int j = i; j < sequence.size()-1; j++)
        {
            if(sequence[j] > sequence[sequence.size()-1])
                right.push_back(sequence[j]);
        }
        
        if((left.size() + right.size()) != (sequence.size()-1))
            return false;
        
        return verifySquence(left) && verifySquence(right);
    }
};