剑指offer ：二叉搜索树的后序遍历序列

刷一刷题，活动活动大脑，留下简略的思考过程，以备回看。

题目描述

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

补充：

给定的二叉树中每个元素值的大小是根据中序遍历得到的。
例如如下图片（如示，为该方法的C解法），二叉树中的每个元素编码为中序遍历后赋值，值越小，越先被遍历到。该二叉树的后序遍历序列为{5，7，6，9，11，10，8}。

思路

对问题的理解：
1. 二叉树节点的值的大小，是根据中序遍历的先后顺序赋值的。中序遍历为“左中右”，在二叉树中表现为：左节点的值 < 根节点的值 < 右节点的值。
2. 后序遍历的特征为“左右根”，即后序遍历的数组的最后一位为根节点。比根节点小的节点一定均位于二叉树的左子树中，在后序遍历的数组中表现为“比根节点小的数组元素一定都位于数组前端”。同理，比根节点大的节点一定均位于二叉树的右子树中，在后序遍历的数组中表现为“比根节点大的数组元素一定都位于数组后端”。

如何解题：
1. 根据数组，获取根节点。比根节点小的前半段数组为左子树；比根节点大的后半段数组为右子树。
2. 如果给定的测试数组不满足这个条件，则该数组非后续遍历序列。
3. 如果给定的测试数组满足这个条件，继续：左子树数组和右子树数组亦为后序遍历得到的数组，迭代算法，将左子树数组和右子树数组分别送入算法中。
4. 迭代算法的终止条件是其中的重点，表面上来说，关系到算法是否正确输出；更深层次看，则表明了对算法的理解程度。

Python代码

内容为class Solution中的代码，末尾4行为自己的测试代码。

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        if len(sequence) <= 0:
            return False

        root = sequence[-1]
        mid = 0
        for i in range(len(sequence)-1):
            mid = i
            if sequence[i] > root:
                break

        if mid < len(sequence)-1:
            for j in range(mid+1, len(sequence)-1):
                if sequence[j] < root:
                    return False

        left_flag = True
        right_flag = True
        if mid > 0:
            left_flag = self.VerifySquenceOfBST(sequence[:mid])
        if mid < len(sequence)-1:
            right_flag = self.VerifySquenceOfBST(sequence[mid:len(sequence)-1])
        return left_flag & right_flag

if __name__ == '__main__':
    test_sequence = [1,2,3,4,5]
    solution = Solution()
    print(solution.VerifySquenceOfBST(test_sequence))

Java 代码

内容为方法VerifySquenceOfBST( int[] sequence) 中的代码。其余为测试部分。

import java.util.Arrays;

public class JudgePostOrder {
    public static boolean VerifySquenceOfBST(int [] sequence) {
        int n = sequence.length;
        if(sequence==null || n<=0){
            return false;
        }

        int root = sequence[n-1];
        int i=0;
        for(;i<n-1;i++) {
            if(sequence[i]>root) {
                break;
            }
        }
        int mid = i;
        for(;i<n-1; i++){
            if(sequence[i]<root){
                return false;
            }
        }
        boolean leftFlag = true;
        boolean rightFlag = true;
        if(mid>0){
            leftFlag = VerifySquenceOfBST(Arrays.copyOfRange(sequence,0,mid));
        }
        if(mid<n-1){
            rightFlag = VerifySquenceOfBST(Arrays.copyOfRange(sequence, mid, n-1));
        }
        return leftFlag&&rightFlag;
    }

    public static void main(String[] args) {
        int[] array = {5,7,6,9,11,10,8};
        int[] array2 = {7,4,6,5};
        System.out.println(VerifySquenceOfBST(array));
    }
}