21.二叉搜索树的后序遍历序列（做第二遍时感觉仍有难度，第三次做时还是要看思路）

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

• 参与人数：3258时间限制：1秒空间限制：32768K
•  算法知识视频讲解

题目描述

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

vector是否为空：vector.empty()，而不是vector == NULL。现在写递归有些头绪了。

// 22.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
using namespace::std;

class Solution {
public:
	bool VerifySquenceOfBST(vector<int> s) {
		if ( s.empty() ) return false ;

		int length = s.size();
		int rootVal = s[length - 1];
		vector<int> leftVec;
		vector<int> rigthVec;
		bool retVal = true;

		int i = 0;
		for (; i < length - 1; i++) {
			if (s[i] < rootVal) {
				leftVec.push_back(s[i]);
			}
			else {
				break;
			}
		}		
		for (; i < length - 1; i++) {
			rigthVec.push_back(s[i]);
		}
		for (vector<int>::iterator it = leftVec.begin(); it != leftVec.end(); it++) {
			if (*it > rootVal) {
				return false;
			}
		}
		for (vector<int>::iterator it = rigthVec.begin(); it != rigthVec.end(); it++) {
			if (*it < rootVal) {
				return false;
			}
		}

		bool leftVal = true;
		if (leftVec.size() > 1) {
			leftVal = VerifySquenceOfBST(leftVec);
		}
		bool rightVal = true;
		if (rigthVec.size() > 1) {
			rightVal = VerifySquenceOfBST(rigthVec);
		}
		return (leftVal && rightVal);
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	vector<int>test;

	test.push_back(5);
	test.push_back(7);
	test.push_back(6);
	test.push_back(9);
	test.push_back(11);
	test.push_back(10);
	test.push_back(8);

	Solution s;
	bool v = s.VerifySquenceOfBST(test);
	return 0;
}

第二次做：

第二次做的时候还是看了《剑指offer》上的分析思路。

这道题是一个尾递归，尾递归其实很好写，先把正常的逻辑写好，然后在尾部加入递归，同时在头部加入递归出口条件。

1.写正常逻辑：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> vec) {
		if ( vec.empty() == true ) return false ;
        
        int rootVal = vec[vec.size() - 1] ;
        
        vector<int> leftVec ;
        vector<int> rightVec ;
        int mid = 0 ;
        
        for ( int i = 0; i < vec.size(); ++ i ) {
            if ( vec[i] < rootVal ){
            	leftVec.push_back( vec[i] ) ;
                ++ mid ;
            } else break ;
        }
        
        for ( int i = mid; i < vec.size() - 1; ++ i ) {
            rightVec.push_back( vec[i] ) ;
        }
        
        for ( int i = 0; i < rightVec.size(); ++ i ) {
            if ( rightVec[i] < rootVal ) return false ;
        }
       
        
        return true;
    }
};

在尾部加入递归：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> seq) {
		if ( seq.empty() == true ) return false ;
        
        int rootVal = seq[seq.size() - 1] ;
        vector<int> left ;
        vector<int> right ;
        int mid = 0 ;
        
        for ( int i = 0; i < seq.size(); ++ i ) {
            if ( seq[i] < rootVal ) {
                left.push_back( seq[i] ) ;
                ++ mid ;
            } else {
                break ;
            }
        }
        
        for ( int i = mid; i < seq.size() - 1; ++ i ) {
            right.push_back( seq[i] ) ;
        }
        
        for ( int i = 0; i < right.size(); ++ i ) {
            if ( right[i] < rootVal ) {
                return false ;
            }
        }
        
        bool boolLeft = true ;
        bool boolRight = true ;
        if ( left.empty() == false ) boolLeft = VerifySquenceOfBST( left ) ;
        if ( right.empty() == false ) boolRight = VerifySquenceOfBST( right ) ;
        
        return boolLeft && boolRight ;
    }
};

第三次做：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> seq) {
		if ( seq.empty() == true ) return false ;
        
        int rootVal = seq[seq.size() - 1] ;
        vector<int> left ;
        vector<int> right ;
        int mid = 0 ;
        
        for ( int i = 0; i < seq.size(); ++ i ) {
            if ( seq[i] < rootVal ) {
                left.push_back( seq[i] ) ;
                ++ mid ;
            } else {
                break ;
            }
        }
        
        for ( int i = mid; i < seq.size() - 1; ++ i ) {
            right.push_back( seq[i] ) ;
        }
        
        for ( int i = 0; i < right.size(); ++ i ) {
            if ( right[i] < rootVal ) {
                return false ;
            }
        }
        
        bool boolLeft = true ;
        bool boolRight = true ;
        if ( left.empty() == false ) boolLeft = VerifySquenceOfBST( left ) ;
        if ( right.empty() == false ) boolRight = VerifySquenceOfBST( right ) ;
        
        return boolLeft && boolRight ;
    }
};