class Solution {

public:

    bool VerifySquenceOfBST(vector<int> sequence) {

        if (sequence.size() == )

            return false;

        int len = sequence.size(),i = ,j;

        int root = sequence[len - ];         // 根节点

        vector<int> leftTree, rightTree;

        while (sequence[i] < root){           // 找出左子树的范围 0 ~ i-1

            leftTree.push_back(sequence[i]);  // 将左子树存入一个vector

            i++;

        }

        for (j = i; j < len - ; j++){        // 在右子树的范围 j ~ len-1 内判断有没有不合理的数字

            if (sequence[j] < root){

                return false;

            }

            rightTree.push_back(sequence[j]);  // 将右子树存入一个vector

        }

        bool resofleft = true, resofright = true;             // 这里的初始化重要，是控制判断为真情况的

        if (leftTree.size() > ){                             // 保证子树为空时能够跳过判断

            resofleft = VerifySquenceOfBST(leftTree);         // 递归判断左子树

        }

        if (rightTree.size() > ){

            resofright = VerifySquenceOfBST(rightTree);       // 递归判断右子树

        }

        return (resofleft && resofright);                     // 左右子树都返回为真时，才为真

    }

};

# -*- coding:utf-8 -*-

class Solution:

    def VerifySquenceOfBST(self, sequence):

        # write code here

        if not sequence:

            return False

        leng = len(sequence)

        root = sequence[leng - 1]

        i = 0

        ltree = []

        rtree = []

        while sequence[i] < root:

            ltree.append(sequence[i])

            i = i + 1

        j = i

        for j in range(j, leng - 1):

            if sequence[j] < root:

                return False

            rtree.append(sequence[j])

        leftTree = True

        rightTree = True

        if len(ltree) :

            leftTree = self.VerifySquenceOfBST( ltree)

        if len(rtree) :

            rightTree = self.VerifySquenceOfBST( rtree)

        return (leftTree and rightTree)