二叉搜索树的后序遍历序列

private  boolean VerifySquenceOfBST(int[] sequence){
            if(sequence.length == 0)
                return false;
            List<Integer> leftArray = new ArrayList<Integer>();
            List<Integer> rightArray = new ArrayList<Integer>();
            int root = sequence[sequence.length - 1];
            //获得左子树和右子树
            boolean startRight = false;
            for(int i = 0;i < sequence.length - 1;i ++){
                if(sequence[i] < root && startRight == false){
                    leftArray.add(sequence[i]);
                }
                else
                    startRight = true;
                if(startRight == true && root < sequence[i]){
                    rightArray.add(sequence[i]);
                }
            }
            //判断是否符合搜索二叉树性质
            if(leftArray.size() + rightArray.size() != sequence.length - 1)
                return false;
            //递归
            else{
                //ArrayList转int[]数组
                int[] left = new int[leftArray.size()];
                int[] right = new int[rightArray.size()];
                for(int i = 0;i < left.length;i ++){
                    left[i] = leftArray.get(i);
                }
                for(int j = 0;j < right.length;j ++){
                    right[j] = rightArray.get(j);
                }
                //因为int.length == 0时为false,这里要判断递归入口，使数组长度为0不返回false
                if(left.length != 0 && right.length == 0)
                    return VerifySquenceOfBST(left);
                else if(right.length != 0 && left.length == 0)
                    return VerifySquenceOfBST(right);
                else if(left.length == 0 && right.length == 0)
                    return true;
                else
                    return VerifySquenceOfBST(left) && VerifySquenceOfBST(right);
            }