面试100题：9.判断整数序列是不是二元查找树的后序遍历结果

题目：

输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。如果是返回true，否则返回false。

例如输入5, 7, 6, 9, 11, 10, 8，由于这一整数序列是如下树的后序遍历结果：

          8

      /      \

    6       10

  /  \      /    \

5     7  9    11

因此返回true。

如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。

分析：

在后续遍历得到的序列中，最后一个元素为树的根结点。从头开始扫描这个序列，比根结点小的元素都应该位于序列的左半部分；从第一个大于跟结点开始到跟结点前面的一个元素为止，所有元素都应该大于跟结点，因为这部分元素对应的是树的右子树。根据这样的划分，把序列划分为左右两部分，我们递归地确认序列的左、右两部分是不是都是二元查找树。

解一：

1. /*Title: 9.判断整数序列是不是二元查找树的后序遍历结果：解一 
2. Author:  gocode 
3. Date:    2012-10-12*/  
4.    
5. #include <iostream>  
6. using namespace std;  
7.    
8. bool verifyBSTPostSort(int squence[], int length)  
9. {  
10.     // 判断数组是否为空或长度为0  
11.     if(squence == NULL || length <= 0)  
12.         return false;  
13.    
14.     // 后序排序二叉树的根节点是数组的最后一个，这是后序排序的特点  
15.     int root = squence[length - 1];  
16.    
17.     // 左子树的值永远要小于根节点，否则就可以判定该数组序列不是后序排序的二叉树  
18.     // squence[i]>root表明此时squence[i]进入右子树区间  
19.     int i = 0;  
20.     for(; i < length - 1; ++i)  
21.     {  
22.         if(squence[i] > root)  
23.             break;  
24.     }  
25.    
26.     // 右子树的值永远要大于根节点，否则就可以判定该数组序列不是后序排序的二叉树  
27.     // j = i 继续检查右子树  
28.     int j = i;  
29.     for(; j < length - 1; ++j)  
30.     {  
31.         if(squence[j] < root)  
32.             return false;  
33.     }  
34.    
35.     // 在区间点i，继续对两个区间检查  
36.     // left和right的初值不能设定为false，这是要考虑到区间为一个数值的情况。  
37.     // 区间为一个值时，上面2个for循环已经不起作用了，并且下面2个if语句为false  
38.     // 此时如果left，right的初值设为false，则区间为一个值时就会返回false，导致判断出错。  
39.     bool left = true;   
40.     if(i > 0)  
41.         left = verifyBSTPostSort(squence, i);  
42.    
43.     bool right = true;  
44.     if(i < length - 1)  
45.         right = verifyBSTPostSort(squence + i, length - i - 1);  
46.    
47.     return(left && right);  
48. }  
49.    
50. void main()  
51. {  
52.     int a[] = {5, 7, 6, 9, 11, 10, 8};  
53.    
54.     cout<<"The result is: "<<verifyBSTPostSort(a, 7)<<endl;  
55.     getchar();  
56. }  

解二：

1. /*Title: 9.判断整数序列是不是二元查找树的后序遍历结果：解二 
2. Author:  gocode 
3. Date:    2012-10-12*/  
4.   
5. #include <iostream>  
6. #include <climits>  
7. using namespace std;  
8.    
9. #define N 100  
10.    
11. bool judge(int a[], int len, int stk[])  
12. {  
13.     int top=1; //栈顶指针  
14.    
15.     for(int i=len-1; i>=0; --i)  
16.     {  
17.         if (a[i]>=stk[top]) //如果不能插入到栈中，返回false  
18.             return false;  
19.    
20.         while (a[i]<stk[top]) //在数组a[i]中查找第一个不大于stk[top]的数  
21.         {  
22.             --top;  
23.         }  
24.         if (a[i] == stk[top]) //如果啊a[i]与栈中元素相同返回false  
25.             return false;  
26.    
27.         // 把栈中比a[i]大的那个数向右移一个位置，把a[i]插到栈中  
28.         top += 2;  
29.         stk[top] = stk[top-1];  
30.         stk[top-1] = a[i];  
31.     }  
32.    
33.     return true;  
34. }  
35.    
36. int main()  
37. {  
38.     // INT_MAX = 2147483647  
39.     // INT_MIN = -2147483648  
40.     int stack[N]={INT_MIN, INT_MAX};  
41.     int a[]={5, 7, 6, 9, 11, 10, 8};  
42.       
43.     cout<<"The result is: "<<judge(a,7,stack)<<endl ;  
44.     cout<<"The stack is: "<<endl;  
45.     // 根据数组长度6列出栈内的值，顺序为栈顶到栈底  
46.     for(int j = 6; j >= 0; --j)  
47.         cout<<stack[j]<<" ";  
48.     getchar();  
49. }