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

题目描述

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

解题思路

利用BST的根结点可以划分左右子树，左子树都比根结点小，右子树比根结点大，递归。需要注意特殊的二叉搜索树，比如 1 2 3 和 3 2 1 这两种。

Code

• 初始版本

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        return VerifySquenceOfBSTCore(sequence, 0, sequence.size()-1);
    }
    bool VerifySquenceOfBSTCore(vector<int> sequence, int st, int ed) {
        if(!sequence.size()) {
            return false;
        } else if(ed == st) {
            return true;
        } else if(ed - st == 1) {
            return true;
        }
        int root = sequence[ed], i, cnt = 0, idx = -1;
        for(i = st+1; i<ed; i++) {
            if(root > sequence[i-1] && root < sequence[i]){
                cnt++;
                idx = i;
            } else if(root > sequence[i] && root < sequence[i-1]) {
                return false;
            }
        }
        if(cnt > 1) {
            return false;
        } else if(cnt == 1) {
            return VerifySquenceOfBSTCore(sequence, st, idx-1) && VerifySquenceOfBSTCore(sequence, idx, ed-1);
        } else {
            return VerifySquenceOfBSTCore(sequence, st, ed-1);
        }
        
    }
};

• 书上的代码

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        return VerifySquenceOfBSTCore(sequence, 0, sequence.size()-1);
    }
    bool VerifySquenceOfBSTCore(vector<int> sequence, int st, int ed) {
        if(!sequence.size()) {
            return false;
        }
        int root = sequence[ed], i;
        for(i = st; i<ed; i++) {
            if(root < sequence[i]) {
                break;
            }
        }
        int j = i;
        for(; j<ed; j++) {
            if(root > sequence[j]) {
                return false;
            }
        }
        bool leftTree = true, rightTree = true;
        if(i-1 > st) {
            leftTree = VerifySquenceOfBSTCore(sequence, st, i-1);
        }
        if(i < ed-1) {
            rightTree = VerifySquenceOfBSTCore(sequence, i, ed-1);
        }
        return leftTree && rightTree;
    }
};

• java

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        return VerifySequenceOfBST(sequence, 0, sequence.length-1);
    }
    public boolean VerifySequenceOfBST(int []sequence, int left, int right) {
        if(left > right) return false;
        int root = sequence[right];
        int mid = left;
        while(mid<=right && sequence[mid]<root) mid++;
        for(int i = mid; i<right; i++) {
            if(root > sequence[i]) return false;
        }
        boolean result = true;
        if(mid-1 > left) {
            result = VerifySequenceOfBST(sequence, left, mid-1);
        }
        if(result && mid < right-1) {
            result = VerifySequenceOfBST(sequence, mid, right-1);
        }
        return result;
    }
}