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

要求

• 时间限制：1秒
• 空间限制：32768K
• 热度指数：324020

题目描述

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

思路

思路一：递归版本

给定的序列需要满足如下条件：最后一个值可以将序列分成左右两个子序列，其中左子序列所有值都小于最后一个值，右子序列的所有值都大于最后一个值。并且左右两个子序列也可以按照上述划分并且满足划分后的条件。

python实现

# -*- coding:utf-8 -*-
class Solution:
    def splitcorrect(self, sequence, l, r):
        if l >= r:
            return True
        temp = l
        for i in range(l, r):
            if sequence[i] > sequence[r]:
                break
            else:
                temp += 1
        mid = temp
        for i in range(mid, r):
            if sequence[i] < sequence[r]:
                break
            else:
                temp += 1
        return temp == r and self.splitcorrect(sequence, l, mid-1) and self.splitcorrect(sequence, mid, r-1)
    
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if len(sequence) == 0:
            return False
        return self.splitcorrect(sequence, 0, len(sequence)-1)

• 运行时间：28ms
• 占用内存：5856k

C++实现

第一次自行实现的版本。这里面空间复杂度为$O(n)$。

class Solution {
public:
    int flag=0;
    bool VerifySquenceOfBST(vector<int> sequence) {
        int length = sequence.size();
        // 第一次进来为空则返回false
        if (flag==0 && length==0)
            return false;
        // 迭代后为空则也是属于满足条件的
        if (length==1 || length==0)
            return true;
        int mid = 0;
        vector<int> seq1;
        for (int i=0; i<length-1; i++)
            if (sequence[i]>sequence[length-1])
                break;
            else{ 
                mid++;
                seq1.push_back(sequence[i]);
            }
        
        vector<int> seq2;
        for (int i=mid; i<length-1; i++)
            if (sequence[i] < sequence[length-1])
                break;
            else{
                mid++;
                seq2.push_back(sequence[i]);
            }
        flag++;
        return mid==length-1 && VerifySquenceOfBST(seq1) &&
            VerifySquenceOfBST(seq2);

    }
};

• 运行时间：3ms

• 占用内存：476k

下面这个版本的空间复杂度为$O(1)$。

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if (sequence.size()==0)
            return false;
        return judgeLast(sequence, 0, sequence.size()-1);
    }
    bool judgeLast(vector<int> sequence, int l, int r) {
        // 第一次进来l不会可r相等，不然就全为0了；
        // 在之后的判断中，为空或者只有一个元素都满足条件
        if (l >= r)
            return true;
        int i = l; int mid = l;
        for (i=l; i<r; i++)
            if (sequence[i]>sequence[r])
                break;
            else
                mid++;
        int temp = mid;
        for (i=mid; i<r; i++)
            if (sequence[i]<sequence[r])
                break;
            else
                mid++;
       return mid==r && judgeLast(sequence, l, temp-1) && 
           judgeLast(sequence, temp, r-1);
    }
};

• 运行时间：3ms

• 占用内存：484k

思路二：非递归版本