【LeetCode-剑指Offer】33. 二叉搜索树的后序遍历序列

一、题目

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

参考以下这颗二叉搜索树：

     5
    / \
   2   6
  / \
 1   3

示例 1：

输入: [1,6,3,2,5]
输出: false

示例 2：

输入: [1,3,2,6,5]
输出: true

提示：

数组长度 <= 1000

二、解决

1、递归

思路：

后序遍历顺序： 左 - 右 - 根

二叉搜索树定义：all val in root.left < root.val < all val in root.right

推论：后序遍历二叉搜索树可以确定根节点root一定在最后一个位置，然后可以用root.val划分出左右子树区间，左边的全部小于root.val，右边全部大于root.val。

过程：遍历数组区间[i, j]元素，寻找第一个大于根节点的节点，下标记为m。此时可划分左子树区间[i, m-1]，右子树区间[m, j-1]，根节点索引 j。

代码：

class Solution {
    public boolean verifyPostorder(int[] postorder) {
        return recur(postorder, 0, postorder.length - 1);
    }
    boolean recur(int[] postorder, int start, int end) {
    	// Terminator：仅仅一个节点，无需判别正确性
        if(start >= end) return true;
        // Current logic：划分左右子树
        int pos = start;               
        while(postorder[pos] < postorder[end]) pos++;
        int separate = pos;
        while(postorder[pos] > postorder[end]) pos++;
        // Drill down：pos==end，才能判断为此树正确
        return pos == end && recur(postorder, start, separate - 1) && recur(postorder, separate, end - 1);
    }
}

时间复杂度： $O(n^2)$，最差情况退化为链表，每轮递归都需要遍历树所有节点，占用$O(n)$。
空间复杂度： $O(n)$。

2、辅助栈

思路：

后序遍历倒序：根 - 右 - 左（根<右，根>左，右>左），类似先序遍历镜像。先序是 根 - 左- 右。

后续遍历结果：[3，6，5，9，8，11，13，12，10]
从前往后不好看，逆序一下：【10，12，13，11，8，9，5，6，3】

观察总结：1）挨着的两个数如果arr[i]<arr[i+1]，那么arr[i+1]一定是arr[i]的右子节点。
2）如果arr[i]>arr[i+1]，那么arr[i+1]一定是arr[0]…arr[i]中某个节点的左子节点，并且这个值是大于arr[i+1]中最小的。

• 为什么说“某个节点”是最小？
• 反转后顺序是 根–>右–>左；arr[i]>arr[i+1]，说明arr[i]是右或根（如果没有右子树）节点；arr[i+1]是左子树的第一个节点，而且是左子树的根节点。那这里的“某个节点”就是arr[i+1]的父节点，是根，小于右子树全部节点的值，所以说最小。

举个例子如下：可以看 13 & 11，12是大于11中最小的，9 & 5， 8 是大于5中最小的 。

分析可得：可以用栈解决问题，遍历数组所有元素，如果栈为空，就把当前元素压栈。如果栈不为空，并且当前元素大于栈顶元素，说明是升序的，那么就说明当前元素是栈顶元素的右子节点，就把当前元素压栈，如果一直升序，就一直压栈。
当前元素小于栈顶元素，说明是倒序的，说明当前元素是某个节点的左子节点，我们目的是要找到这个左子节点的父节点，就让栈顶元素出栈，直到栈为空或栈顶元素小于当前值为止，其中最后一个出栈的就是当前元素的父节点。

代码：

class Solution {
    public boolean verifyPostorder(int[] postorder) {
	    Stack<Integer> stack = new Stack<>();
	    int parent = Integer.MAX_VALUE;
	    // 注意for循环是倒序遍历的
	    for (int i = postorder.length - 1; i >= 0; i--) {
	        int cur = postorder[i];
	        // 当如果前节点小于栈顶元素，说明栈顶元素和当前值构成了倒序列，
	        // 说明当前节点是前面某个节点的左子节点，我们要找到他的父节点
	        while (!stack.isEmpty() && stack.peek() > cur)
	            parent = stack.pop();
	        // 只要遇到了某一个左子节点，才会执行上面的代码，才会更新parent的值，
	        // 否则parent就是一个非常大的值，也就是说如果一直没有遇到左子节点，
	        // 那么右子节点可以非常大
	        if (cur > parent)
	            return false;
	        // 入栈
	        stack.add(cur);
	    }
	    return true;
	}
}

时间复杂度： $O(n)$
空间复杂度： $O(n)$

三、参考

1、面试题33. 二叉搜索树的后序遍历序列（递归分治 / 单调栈，清晰图解）
2、递归和栈两种方式解决，最好的击败了100%的用户
3、单调递增栈辅助，逆向遍历数组