判斷一棵二叉樹是否爲BST，一棵樹是否爲徹底二叉樹

對於一顆搜索二叉樹，最簡單的方法就是用中序遍歷，看是否是一個遞增數列，若是是則是一顆搜索二叉樹，若是不是則不是搜索二叉樹。在這裏用一個lastVisit去記錄上一次搜索到的節點。整個過程就是先找到最左下角的節點，更新這個lastVisit爲這個節點的值，而後按照中序遍歷依次更新便可。代碼以下。

 1 #include <stdio.h>
 2 #include <climits>
 3 
 4 //二叉樹結點
 5 typedef struct binary_tree_node_t{
 6     binary_tree_node_t * left;
 7     binary_tree_node_t * right;
 8     int  elem;
 9 
10 };
11 
12 //若是是BST, 其中序遍歷應該是從小到大的順序
13 int lastVisit = INT_MIN;
14 
15 int judge_BST(binary_tree_node_t * root){
16     if(root == NULL){
17         return 1;
18     }
19 
20     int judgeLeft = judge_BST(root->left);//先判斷左子樹
21 
22     if( (root->elem >= lastVisit) && judgeLeft == 1){//當前結點比上次訪問的數值要大
23         lastVisit = root->elem;
24     }else{
25         return 0;
26     }
27 
28     int judgeRight = judge_BST(root->right);//最後右子樹
29 
30     return judgeRight;
31 
32 }
33 
34 
35 //判斷一顆二叉樹是否是二叉排序樹
36 int main(){
37     binary_tree_node_t ns[10];
38 
39     for(int i = 1; i <= 6; i++){
40         binary_tree_node_t tmp;    
41         tmp.elem  = i;
42         tmp.left = NULL;//必須顯式初始化爲NULL
43         tmp.right = NULL;
44         ns[i] = tmp;
45     }
46     
47     binary_tree_node_t root;
48     root.elem = 4;
49 
50     root.left = &ns[2];
51     root.right = &ns[5];
52 
53     ns[2].left = &ns[1];
54     ns[2].right = &ns[3];
55      
56     ns[5].right = &ns[6];
57 
58 
59     printf("%d\n", judge_BST(&root));
60 
61     return 0;
62 }

對於一顆徹底二叉樹採用廣度優先遍歷，從根節點開始，入隊列，若是隊列不爲空，循環。遇到第一個沒有左兒子或者右兒子的節點，設置標誌位，若是以後再遇到有左/右兒子的節點，那麼這不是一顆徹底二叉樹。這個方法須要遍歷整棵樹，複雜度爲O(N)，N爲節點的總數。

 1     //二叉樹結點定義  
 2     typedef struct Node  
 3     {  
 4         int data;  
 5         struct Node* left;  
 6         struct Node* right;  
 7     }Node;  
 8       
 9     //實現廣度遍歷須要隊列  
10     Queue<Node*> queue;  
11       
12     //第n層最右節點標誌  
13     bool leftMost = false;  
14       
15     bool ProcessChild(Node* child)  
16     {  
17         if (child)  
18         {  
19             if (!leftMost)  
20             {  
21                 queue.push(child);  
22             }  
23             else  
24             {  
25                 return false;  
26             }  
27         }  
28         else  
29         {  
30             leftMost = true;  
31         }  
32       
33         return true;  
34     }  
35       
36     bool IsCompleteBinaryTree(Node* root)  
37     {  
38         //空樹也是徹底二叉樹  
39         if (!root)  
40             return true;  
41       
42         //首先根節點入隊列  
43         queue.push(root);  
44       
45         while(!queue.empty())  
46         {  
47             Node* node = queue.pop();  
48       
49             //處理左節點  
50             if (!ProcessChild(node->left))  
51                 return false;  
52       
53             //處理右節點  
54             if (!ProcessChild(node->right))  
55                 return false;  
56         }  
57       
58         //廣度優先遍歷完畢，此乃徹底二叉樹  
59         return true;  
60     }