树

  今天，我们一起用C++写一颗树，目的是熟练C++的语法细节，具体如下：

LinkQueue.h内容如下：

[cpp]  view plain copy

1. #include "QueueNode.h"  
2.   
3. template<typename Type> class LinkQueue{  
4. public:  
5.     LinkQueue() :m_prear(NULL), m_pfront(NULL){}  
6.     ~LinkQueue(){  
7.         MakeEmpty();  
8.     }  
9.     void Append(const Type item);  
10.     Type Delete();  
11.     Type GetFront();  
12.     void MakeEmpty();  
13.     bool IsEmpty() const{  
14.         return m_pfront == NULL;  
15.     }  
16.     void Print();  
17.   
18. private:  
19.     QueueNode<Type> *m_prear, *m_pfront;  
20. };  
21.   
22. template<typename Type> void LinkQueue<Type>::MakeEmpty(){  
23.     QueueNode<Type> *pdel;  
24.     while (m_pfront){  
25.         pdel = m_pfront;  
26.         m_pfront = m_pfront->m_pnext;  
27.         delete pdel;  
28.     }  
29. }  
30.   
31. template<typename Type> void LinkQueue<Type>::Append(const Type item){  
32.     if (m_pfront == NULL){  
33.         m_pfront = m_prear = new QueueNode<Type>(item);  
34.     }  
35.     else{  
36.         m_prear = m_prear->m_pnext = new QueueNode<Type>(item);  
37.     }  
38. }  
39.   
40. template<typename Type> Type LinkQueue<Type>::Delete(){  
41.     if (IsEmpty()){  
42.         cout << "There is no element!" << endl;  
43.         exit(1);  
44.     }  
45.     QueueNode<Type> *pdel = m_pfront;  
46.     Type temp = m_pfront->m_data;  
47.     m_pfront = m_pfront->m_pnext;  
48.     delete pdel;  
49.     return temp;  
50. }  
51.   
52. template<typename Type> Type LinkQueue<Type>::GetFront(){  
53.     if (IsEmpty()){  
54.         cout << "There is no element!" << endl;  
55.         exit(1);  
56.     }  
57.     return m_pfront->m_data;  
58. }  
59.   
60. template<typename Type> void LinkQueue<Type>::Print(){  
61.     QueueNode<Type> *pmove = m_pfront;  
62.     cout << "front";  
63.     while (pmove){  
64.         cout << "--->" << pmove->m_data;  
65.         pmove = pmove->m_pnext;  
66.     }  
67.     cout << "--->rear" << endl << endl << endl;  
68. }  

QueueNode.h内容如下：

[cpp]  view plain copy

1. template<typename Type> class LinkQueue;  
2.   
3. template<typename Type> class QueueNode{  
4. private:  
5.     friend class LinkQueue < Type > ;  
6.     QueueNode(const Type item, QueueNode<Type> *next = NULL)  
7.         :m_data(item), m_pnext(next){}  
8. private:  
9.     Type m_data;  
10.     QueueNode<Type> *m_pnext;  
11. };  

Tree.h内容如下：

[cpp]  view plain copy

1. #include "TreeNode.h"  
2. #include "LinkQueue.h"  
3.   
4. template<typename Type> class Tree{  
5. public:  
6.     Tree() :m_proot(NULL), m_pcurrent(NULL){}  
7. public:  
8.     TreeNode<Type> *GetCurrent(){ //Get the current node  
9.         return m_pcurrent;  
10.     }  
11.     void SetCurrent(TreeNode<Type> *current){ //set the current node  
12.         m_pcurrent = current;  
13.     }  
14.     bool Insert(Type item);     //insert an new node to current node  
15.     void Remove(Type item);     //delete the node whose data is equal to item  
16.     void Remove(TreeNode<Type> *current); //delete the node  
17.     bool Find(Type item);       //find the node whose data is equal to item  
18.     void PrintChild(TreeNode<Type> *current); //print the child tree  
19.     TreeNode<Type> *Parent(TreeNode<Type> *current);    //get the parent  
20.   
21.     void Print();               //print the tree  
22.     void PreOrder(TreeNode<Type> *root);  //ordering the tree by visiting the root first  
23.     void PostOrder(TreeNode<Type> *root); //ordering the tree by visiting the root last  
24.     void LevelOrder(TreeNode<Type> *root);    //ordering the tree by level  
25.     void PreOrder();  
26.     void PostOrder();  
27.     void LevelOrder();  
28.   
29. private:  
30.     TreeNode<Type> *m_proot, *m_pcurrent;  
31.     bool Find(TreeNode<Type> *root, Type item);  
32.     void Remove(TreeNode<Type> *root, Type item);  
33.     TreeNode<Type> *Parent(TreeNode<Type> *root, TreeNode<Type> *current);  
34.     void Print(TreeNode<Type> *start, int n = 0);  
35. };  
36.   
37. template<typename Type> bool Tree<Type>::Insert(Type item){  
38.     TreeNode<Type> *newnode = new TreeNode<Type>(item);  
39.     if (NULL == newnode){  
40.         cout << "Application Error!" << endl;  
41.         exit(1);  
42.     }  
43.     if (NULL == m_proot){  
44.         m_proot = newnode;  
45.         m_pcurrent = m_proot;  
46.         return 1;  
47.     }  
48.     if (NULL == m_pcurrent){  
49.         cerr << "insert error!" << endl;  
50.         return 0;  
51.     }  
52.   
53.     if (NULL == m_pcurrent->m_pfirst){  
54.         m_pcurrent->m_pfirst = newnode;  
55.         m_pcurrent = newnode;  
56.         return 1;  
57.     }  
58.     TreeNode<Type> *pmove = m_pcurrent->m_pfirst;  
59.     while (pmove->m_pnext){  
60.         pmove = pmove->m_pnext;  
61.     }  
62.     pmove->m_pnext = newnode;  
63.     m_pcurrent = newnode;  
64.     return 1;  
65.   
66. }  
67.   
68. template<typename Type> void Tree<Type>::Remove(TreeNode<Type> *current){  
69.     if (NULL == current){  
70.         return;  
71.     }  
72.     TreeNode<Type> *temp = Parent(current);  
73.     if (NULL == temp){  
74.         TreeNode<Type> *pmove = current->m_pfirst;  
75.         if (NULL != pmove->m_pfirst){  
76.             pmove = pmove->m_pfirst;  
77.             while (pmove->m_pnext){  
78.                 pmove = pmove->m_pnext;  
79.             }  
80.             pmove->m_pnext = current->m_pfirst->m_pnext;  
81.             current->m_pfirst->m_pnext = NULL;  
82.         }  
83.         else{  
84.             pmove->m_pfirst = pmove->m_pnext;  
85.         }  
86.         m_proot = current->m_pfirst;  
87.     }  
88.     else{  
89.         if (temp->m_pfirst == current){  
90.             TreeNode<Type> *pmove = current->m_pfirst;  
91.             if (pmove){  
92.                 while (pmove->m_pnext){  
93.                     pmove = pmove->m_pnext;  
94.                 }  
95.                 pmove->m_pnext = current->m_pnext;  
96.             }  
97.             else{  
98.                 current->m_pfirst = current->m_pnext;  
99.             }  
100.   
101.         }  
102.         else{  
103.             TreeNode<Type> *pmove = temp->m_pfirst;  
104.             while (pmove->m_pnext != current){  
105.                 pmove = pmove->m_pnext;  
106.             }  
107.             pmove->m_pnext = current->m_pnext;  
108.             while (pmove->m_pnext){  
109.                 pmove = pmove->m_pnext;  
110.             }  
111.             pmove->m_pnext = current->m_pfirst;  
112.         }  
113.     }  
114.     delete current;  
115. }  
116.   
117. template<typename Type> void Tree<Type>::Remove(TreeNode<Type> *root, Type item){  
118.     if (NULL == root){  
119.         return;  
120.     }  
121.     if (root->m_pfirst){  
122.         TreeNode<Type> *pmove = root->m_pfirst;  
123.         while (pmove){  
124.             Remove(pmove, item);  
125.             pmove = pmove->m_pnext;  
126.         }  
127.     }  
128.     if (root->m_data == item){  
129.         Remove(root);  
130.     }  
131.   
132. }  
133. template<typename Type> void Tree<Type>::Remove(Type item){  
134.     return Remove(m_proot, item);  
135. }  
136.   
137. template<typename Type> TreeNode<Type>* Tree<Type>::Parent(  
138.     TreeNode<Type> *root, TreeNode<Type> *current){  
139.     if (NULL == root){  
140.         return NULL;  
141.     }  
142.     TreeNode<Type> *pmove = root->m_pfirst, *temp;  
143.     if (NULL != pmove){  
144.         while (pmove){  
145.             if (pmove == current){  
146.                 return root;  
147.             }  
148.             pmove = pmove->m_pnext;  
149.         }  
150.     }  
151.     pmove = root->m_pfirst;  
152.     while (pmove){  
153.         temp = Parent(pmove, current);  
154.         if (temp){  
155.             return temp;  
156.         }  
157.         pmove = pmove->m_pnext;  
158.     }  
159.     return NULL;  
160. }  
161.   
162. template<typename Type> TreeNode<Type>* Tree<Type>::Parent(TreeNode<Type> *current){  
163.     return Parent(m_proot, current);  
164. }  
165.   
166. template<typename Type> void Tree<Type>::PrintChild(TreeNode<Type> *current){  
167.     TreeNode<Type> *pmove = current->m_pfirst;  
168.     cout << "first";  
169.     if (NULL != pmove){  
170.         cout << "--->" << pmove->m_data;  
171.     }  
172.     while (pmove->m_pnext){  
173.         cout << "--->" << pmove->m_data;  
174.         pmove = pmove->m_pnext;  
175.     }  
176. }  
177.   
178. template<typename Type> bool Tree<Type>::Find(TreeNode<Type> *root, Type item){  
179.     if (root->m_data == item){  
180.         return 1;  
181.     }  
182.     if (NULL == root){  
183.         return 0;  
184.     }  
185.     TreeNode<Type> *pmove = root->m_pfirst;  
186.     if (NULL == pmove){  
187.         return 0;  
188.     }  
189.     while (pmove){  
190.         if (Find(pmove, item)){  
191.             return 1;  
192.         }  
193.         pmove = pmove->m_pnext;  
194.     }  
195.     return 0;  
196. }  
197.   
198. template<typename Type> bool Tree<Type>::Find(Type item){  
199.     return Find(m_proot, item);  
200. }  
201.   
202. template<typename Type> void Tree<Type>::Print(TreeNode<Type> *start, int n = 0){  
203.     if (NULL == start){  
204.         for (int i = 0; i < n; i++){  
205.             cout << "     ";  
206.         }  
207.         cout << "NULL" << endl;  
208.         return;  
209.     }  
210.     TreeNode<Type> *pmove = start->m_pfirst;  
211.     Print(pmove, n + 1);  
212.   
213.     for (int i = 0; i < n; i++){  
214.         cout << "     ";  
215.     }  
216.     cout << start->m_data << "--->" << endl;  
217.   
218.     if (NULL == pmove){  
219.         return;  
220.     }  
221.     pmove = pmove->m_pnext;  
222.     while (pmove){  
223.         Print(pmove, n + 1);  
224.         pmove = pmove->m_pnext;  
225.     }  
226. }  
227.   
228. template<typename Type> void Tree<Type>::Print(){  
229.     Print(m_proot);  
230. }  
231.   
232. template<typename Type> void Tree<Type>::PreOrder(TreeNode<Type> *root)  
233. {  
234.     if (NULL == root){  
235.         return;  
236.     }  
237.     cout << root->m_data;  
238.     TreeNode<Type> *pmove = root->m_pfirst;  
239.     while (pmove){  
240.         PreOrder(pmove);  
241.         pmove = pmove->m_pnext;  
242.     }  
243. }  
244.   
245. template<typename Type> void Tree<Type>::PostOrder(TreeNode<Type> *root)  
246. {  
247.     if (NULL == root){  
248.         return;  
249.     }  
250.     TreeNode<Type> *pmove = root->m_pfirst;  
251.     while (pmove){  
252.         PostOrder(pmove);  
253.         pmove = pmove->m_pnext;  
254.     }  
255.     cout << root->m_data;  
256. }  
257.   
258. template<typename Type> void Tree<Type>::PreOrder(){  
259.     PreOrder(m_proot);  
260. }  
261.   
262. template<typename Type> void Tree<Type>::PostOrder(){  
263.     PostOrder(m_proot);  
264. }  
265.   
266. template<typename Type> void Tree<Type>::LevelOrder(TreeNode<Type> *root)  
267. {   //using queue  
268.     LinkQueue<TreeNode<Type> *> queue;  
269.     TreeNode<Type> *pmove, *ptemp;  
270.     if (root != NULL){  
271.         queue.Append(root);  
272.         while (!queue.IsEmpty()){  
273.             ptemp = queue.Delete();  
274.             cout << ptemp->m_data;  
275.             pmove = ptemp->m_pfirst;  
276.             while (pmove){  
277.                 queue.Append(pmove);  
278.                 pmove = pmove->m_pnext;  
279.             }  
280.         }  
281.     }  
282. }  
283.   
284. template<typename Type> void Tree<Type>::LevelOrder()  
285. {  
286.     LevelOrder(m_proot);  
287. }  

TreeNode.h具体内容如下：

[cpp]  view plain copy

1. template<typename Type> class Tree;  
2.   
3. template<typename Type> class TreeNode{  
4. public:  
5.     friend class Tree < Type > ;  
6.   
7. private:  
8.     Type m_data;  
9.     TreeNode<Type> *m_pfirst, *m_pnext;  
10.     TreeNode() :m_pfirst(NULL), m_pnext(NULL){}  
11.     TreeNode(Type item, TreeNode<Type> *first = NULL, TreeNode<Type> *next = NULL)  
12.         :m_data(item), m_pfirst(first), m_pnext(next){}  
13. };  

main.cpp具体内容如下：

[cpp]  view plain copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. #include "Tree.h"  
6.   
7. int main()  
8. {  
9.     Tree<int> tree;  
10.     int init[10] = { 3, 6, 0, 2, 8, 4, 9, 1, 5, 7 };  
11.     for (int i = 0; i < 10; i++){  
12.         tree.Insert(init[i]);  
13.         if (1 == i % 2){  
14.             tree.SetCurrent(tree.Parent(tree.GetCurrent()));  
15.         }  
16.     }  
17.     tree.Print();  
18.     cout << endl << endl << endl;  
19.   
20.     tree.Remove(3);  
21.     tree.Print();  
22.     cout << endl << endl << endl;  
23.   
24.     cout << tree.Find(5) << endl << tree.Find(11) << endl;  
25.   
26.     tree.PreOrder();  
27.     cout << endl;  
28.     tree.PostOrder();  
29.     cout << endl;  
30.     tree.LevelOrder();  
31.     cin.get();  
32.     return 0;  
33. }  

运行效果如图1所示：

图1 运行效果