树的相关基础算法

树的相关基础算法，先序、中序、后序递归与非递归，层次遍历，建立二叉搜索树。

1. #include <iostream>
   
2. #include <stack>
   
3. #include <queue>
   
4. using namespace std;
   
5. 
   
6. typedef struct Tree {
   
7.     int val;
   
8.     struct Tree *lchild, *rchild;
   
9.     int flag;
   
10. }BSTree;
    
11. 
    
12. BSTree* newBSTree(int n)
    
13. {
    
14.     BSTree *tree = new BSTree;
    
15.     tree->val = n;
    
16.     tree->lchild = NULL;
    
17.     tree->rchild = NULL;
    
18.     tree->flag = 0;
    
19.     return tree;
    
20. }
    
21. 
    
22. void createTree(BSTree *&root, int val)
    
23. {
    
24.     if(NULL == root)
    
25.         root = newBSTree(val);
    
26.     else
    
27.     {
    
28.         BSTree* p = root;
    
29.         while(p)
    
30.         {
    
31.             if(val < p->val)
    
32.             {
    
33.                 if(p->lchild)
    
34.                     p = p->lchild;
    
35.                 else
    
36.                 {
    
37.                     p->lchild = newBSTree(val);
    
38.                     return;
    
39.                 }
    
40.             }
    
41.             else if(val > p->val)
    
42.             {
    
43.                 if(p->rchild)
    
44.                     p = p->rchild;
    
45.                 else
    
46.                 {
    
47.                     p->rchild = newBSTree(val);
    
48.                     return;
    
49.                 }
    
50.             }
    
51.         }
    
52.         
    
53.     }
    
54. }
    
55. 
    
56. /***************************************************************************/
    
57. /*递归遍历系列*/
    
58. void PreOrderRecursion(BSTree* root)        //先序遍历：根——左——右
    
59. {
    
60.     if(root == NULL)
    
61.         return;
    
62.     cout << root->val << endl;        
    
63.     if(root->lchild)
    
64.         PreOrderRecursion(root->lchild);
    
65.     if(root->rchild)
    
66.         PreOrderRecursion(root->rchild);
    
67. }
    
68. 
    
69. void InOrderRecursion(BSTree* root)            //中序遍历：左——根——右
    
70. {
    
71.     if(root == NULL)
    
72.         return;
    
73.     if(root->lchild)
    
74.         InOrderRecursion(root->lchild);
    
75.     cout << root->val << ' ';
    
76.     if(root->rchild)
    
77.         InOrderRecursion(root->rchild);    
    
78. }
    
79. 
    
80. void PostOrderRecursion(BSTree* root)        //后序遍历：左——右——根
    
81. {
    
82.     if(root == NULL)
    
83.         return;
    
84.     if(root->lchild)
    
85.         PostOrderRecursion(root->lchild);
    
86.     if(root->rchild)
    
87.         PostOrderRecursion(root->rchild);
    
88.     cout << root->val << ' ';
    
89. }
    
90. 
    
91. /***************************************************************************/
    
92. /*非递归遍历系列*/
    
93. void PreOrderNonRecursion(BSTree* root)            //先序非递归
    
94. {
    
95.     if(!root)
    
96.         return;
    
97.     
    
98.     BSTree* pRoot = root;
    
99.     stack<BSTree*> st;
    
100.     
     
101.     while(pRoot || !st.empty())
     
102.     {
     
103.         while(pRoot)
     
104.         {
     
105.             cout << pRoot->val << ' ';
     
106.             st.push(pRoot);
     
107.             pRoot = pRoot->lchild;
     
108.         }
     
109.         
     
110.         if(!st.empty())
     
111.         {
     
112.             pRoot = st.top();
     
113.             st.pop();
     
114.             pRoot = pRoot->rchild;
     
115.         }
     
116.     }
     
117. }
     
118. 
     
119. void InOrderNonRecursion(BSTree* root)        //中序非递归
     
120. {
     
121.     if(!root)
     
122.         return;
     
123.     
     
124.     BSTree* pRoot = root;
     
125.     stack<BSTree*> st;
     
126.     
     
127.     while(pRoot || !st.empty())
     
128.     {
     
129.         while(pRoot)
     
130.         {
     
131.             st.push(pRoot);
     
132.             pRoot = pRoot->lchild;
     
133.         }
     
134.         
     
135.         if(!st.empty())
     
136.         {
     
137.             pRoot = st.top();
     
138.             st.pop();
     
139.             cout << pRoot->val << ' ';
     
140.             pRoot = pRoot->rchild;
     
141.         }
     
142.     }
     
143. }
     
144. 
     
145. void PostOrderNonRecursion(BSTree* root)        //后序非递归
     
146. {
     
147.     if(!root)
     
148.         return;
     
149.     
     
150.     BSTree* pRoot = root, *q = NULL;
     
151.     stack<BSTree*> st;
     
152.     
     
153.     while(pRoot || !st.empty())
     
154.     {
     
155.         while(pRoot)
     
156.         {
     
157.             st.push(pRoot);
     
158.             pRoot = pRoot->lchild;
     
159.         }
     
160.         pRoot = st.top();
     
161.         if(pRoot->rchild == NULL || pRoot->rchild == q)
     
162.         {
     
163.             cout << pRoot->val << ' ';
     
164.             q = st.top();
     
165.             st.pop();
     
166.             pRoot = NULL;
     
167.         }
     
168.         else
     
169.             pRoot = pRoot->rchild;
     
170.     }
     
171. }
     
172. 
     
173. void LevelReverse(BSTree* root)        //层次递归
     
174. {
     
175.     if(!root)
     
176.         return;
     
177.     
     
178.     queue<BSTree*> qu;
     
179.     qu.push(root);
     
180.     
     
181.     while(!qu.empty())
     
182.     {
     
183.         BSTree* pRoot = qu.front();
     
184.         cout << pRoot->val << ' ';
     
185.         qu.pop();
     
186.         
     
187.         if(pRoot->lchild)
     
188.             qu.push(pRoot->lchild);
     
189.         if(pRoot->rchild)
     
190.             qu.push(pRoot->rchild);
     
191.     }
     
192. }
     
193. 
     
194. /***************************************************************************/
     
195. int main()
     
196. {
     
197.     int array[] = {10, 8, 12, 6, 9, 11, 13};
     
198.     BSTree *root = NULL;
     
199.     int i, length = sizeof array / sizeof array[0];
     
200.     
     
201.     for(i = 0; i < length; i++)
     
202.         createTree(root, array[i]);
     
203.     
     
204.     LevelReverse(root);
     
205.     cout << endl;
     
206. }