排序二叉树

        二叉排序树又叫二叉查找树，英文名称是：Binary Sort Tree.  BST的定义就不详细说了，我用一句话概括：左 < 中 < 右。 根据这个原理，我们可以推断：BST的中序遍历必定是严格递增的。

         在建立一个BST之前，大家可以做一下这个题目（很简单的）：

        已知，某树的先序遍历为：4, 2, 1 ,0, 3, 5, 9, 7, 6, 8. 中序遍历为: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. 请画出该树。

        我们知道，树的基本遍历有4种方式，分别是：

        先序遍历；中序遍历；后续遍历；层次遍历。事实上，知道任意两种方式，并不能唯一地确定树的结构，但是，只要知道中序遍历和另外任意一种遍历方式，就一定可以唯一地确定一棵树，于是，上面那个题目的答案如下：

      下面，我们来看看BST的建立过程，程序如下（没考虑内存泄露）：

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. // BST的结点  
5. typedef struct node  
6. {  
7.     int key;  
8.     struct node *lChild, *rChild;  
9. }Node, *BST;  
10.   
11. // 在给定的BST中插入结点，其数据域为element, 使之称为新的BST  
12. bool BSTInsert(Node * &p, int element)  
13. {  
14.     if(NULL == p) // 空树  
15.     {  
16.         p = new Node;  
17.         p->key = element;  
18.         p->lChild = p->rChild = NULL;  
19.         return true;  
20.     }  
21.   
22.     if(element == p->key) // BST中不能有相等的值  
23.         return false;  
24.   
25.     if(element < p->key)  // 递归  
26.         return BSTInsert(p->lChild, element);  
27.   
28.     return BSTInsert(p->rChild, element); // 递归  
29. }  
30.   
31. // 建立BST  
32. void createBST(Node * &T, int a[], int n)  
33. {  
34.     T = NULL;   
35.     int i;  
36.     for(i = 0; i < n; i++)  
37.     {  
38.         BSTInsert(T, a[i]);  
39.     }  
40. }  
41.   
42. // 先序遍历  
43. void preOrderTraverse(BST T)  
44. {  
45.     if(T)  
46.     {  
47.         cout << T->key << " ";  
48.         preOrderTraverse(T->lChild);  
49.         preOrderTraverse(T->rChild);  
50.     }  
51. }  
52.   
53. // 中序遍历  
54. void inOrderTraverse(BST T)  
55. {  
56.     if(T)  
57.     {  
58.         inOrderTraverse(T->lChild);  
59.         cout << T->key << " ";  
60.         inOrderTraverse(T->rChild);  
61.     }  
62. }  
63.   
64. int main()  
65. {  
66.     int a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8};  
67.     int n = 10;  
68.     BST T;  
69.   
70.     // 并非所有的a[]都能构造出BST,所以，最好对createBST的返回值进行判断  
71.     createBST(T, a, n);  
72.   
73.     preOrderTraverse(T);  
74.     cout << endl;  
75.   
76.     inOrderTraverse(T);  
77.     cout << endl;  
78.   
79.     return 0;  
80. }  

     那么，怎么知道我们这个程序对不对呢？我们输出其先序和中序遍历，这样就可以完全确定这棵树，运行程序，发现先序遍历为：4, 2, 1 ,0, 3, 5, 9, 7, 6, 8. 中序遍历为: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. 好了，这棵树确定了，如上图（已画）。