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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/N1neDing/article/details/83038705

题目描述：

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

解题思路：

后序遍历最后一个元素为根节点，前方小于根节点的连续序列为左子树，大于根节点的连续序列为右子树

如果左子树全部小于根节点，右子树全部大于根节点，则此节点无问题

然后分别对左子树和右子树进行相同的判断，直到将所有元素判断完

参考源码1：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) 
    {   
            if(sequence.size() == 0) return false; 
            if(sequence.size() == 1) return true;
          int num = sequence.back();
          vector<int> leftson,rightson;
          int pos = 0;
          for(int i = 0;i < sequence.size();i++)
          {
                  if(sequence[i] > num)
                  {
                          pos = i;
                          break;
                  }
                  if(sequence[i] == num)
                  {
                          pos = i;
                          break;
                  }
          }
          for(int i = pos;i < sequence.size()-1;i++)
          {
                  if(sequence[i] < num)
                  {
                          return false;
                  }
          }
          for(int i = 0;i < pos;i++)
          {
                  leftson.push_back(sequence[i]);
          }
          for(int i = pos;i<sequence.size()-1;i++)
          {
                  rightson.push_back(sequence[i]);
          }
          if(leftson.size() == 0) return VerifySquenceOfBST(rightson);
          if(rightson.size() == 0) return VerifySquenceOfBST(leftson);
          return VerifySquenceOfBST(leftson) && VerifySquenceOfBST(rightson);
    }   
};

参考源码2：

同样的思路，使用递归

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

举一反三：

对于前序遍历，同样是根据第一个数值为根节点，寻找出左右子树，再对左右子树进行同样的判断。

对于树，很多问题都可以规划为：寻找出根节点，对左右子树进行操作。