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

原题

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

Reference Answer

解题思路:

二叉搜索树满足左孩子的每一个结点都小于根结点，右孩子的每一个结点都大于根结点。

由于是后序遍历，所以根结点在最后的位置。

获取到根结点，通过根结点把左子树和右子树分开，如果左子树和右子树的每个结点的值都满足二叉搜索树的条件(左孩子的每一个结点都小于根结点，右孩子的每一个结点都大于根结点)的话，则进行遍历，否则返回False。

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
        	return False
 
        # 获取根节点
        root = sequence[-1]
 
        # 根据二叉搜索树的性质，左孩子的每个结点的值都小于根节点
        for i in range(len(sequence)):
        	if sequence[i] > root:
        		break
 
        # 判断是否右孩子的每个结点的值都大于根结点
        for j in range(i, len(sequence)):
        	if sequence[j] < root:
        		return False
 
        left = True
        # i > 0 的时候证明有左孩子
        if i > 0:
        	# 递归遍历左孩子
        	left = self.VerifySquenceOfBST(sequence[ : i])
 
        right = True
        # 证明有右孩子，通过i的值不在最后一个结点判断，len(sequence) - 1 为sequence的最后一个结点
        if i < len(sequence) - 1:
        	right = self.VerifySquenceOfBST(sequence[i : -1])
 
        return left and right

Note

自己在这里卡了很久，原因是把index顺序搞错了

错误答案：

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
            return False
        root = sequence[-1]
        mid_index = 0
        for index,count in enumerate(sequence):
            if count > root:
            
                mid_index = index
                
                break
        for count in sequence[mid_index:]:
            if count < root:
                return False
        left_mark = True
        if left_mark  > 0:
            left_mark = self.VerifySquenceOfBST(sequence[:left_mark ])
        right_mark = True
        if left_mark  < len(sequence) - 1:
            right_mark = self.VerifySquenceOfBST(sequence[left_mark :-1])
        return left_mark and right_mark
        
  

如上，就是将赋值放到了if判断语句内造成了错误，故而将判断语句改为:

        for index,count in enumerate(sequence):
        	mid_index = index
            if count > root:
                break

这样既可得到同样答案。

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
            return False
        root = sequence[-1]
        sequence.pop()
        index = 0
        while index < len(sequence):
            if sequence[index] > root:
                break
            index += 1
        mark = index
        while index < len(sequence):
            if sequence[index] <= root:
                return False
            index += 1
        left = True
        if mark > 0:
            left = self.VerifySquenceOfBST(sequence[:mark])
        right = True
        if mark < len(sequence):
            right = self.VerifySquenceOfBST(sequence[mark:])
        return left and right
        
        

C++ Version:

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

三刷：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if (sequence.empty()) return false;
        int index = 0;
        int root = sequence.back();
        sequence.pop_back();
        while (index < sequence.size()){
            if (sequence[index] > root) break;
            index ++;
        }
        int mark = index;
        while (index < sequence.size()){
            if (sequence[index] < root) {
                return false;
            }
            index ++;
        }
        bool left = true;
        vector<int> temp;
        for(int i = 0; i < mark; ++i) temp.push_back(sequence[i]);
        if (mark > 0) left = VerifySquenceOfBST(temp);
        
        bool right = true;
        temp.clear();
        for(int i = mark; i < sequence.size(); ++i) temp.push_back(sequence[i]);
        if (mark < sequence.size()) right = VerifySquenceOfBST(temp);
        return left && right;
        
    }
};

注：

1. for i in range(len((list))中的i是可以接着使用的，相当于普通函数变量；
2. 注意递归的两个判定条件：if (i > begin) , if (i < end-1)；