二叉树遍历算法集合(前中后序遍历的递归和非递归算法,层序遍历算法)

 全文为转载，版权归原作者所有.

 

费了两天时间写的,包括前中后序遍历的递归和非递归算法,还有层序遍历总共2*3 + 1 = 7中遍历二叉树的算法,感觉其中后序遍历的非递归算法比较困难,想了很久最后的实现还是不够优雅,请大家指正~~

总共三个文件,一个头文件,一个对应的cpp文件,还有一个用于测试的文件.

 

1. /**//********************************************************************
2.     created:    2006/07/04
3.     filename:     BinaryTree.h
4.     author:        李创
5.                 http://www.cppblog.com/converse/
7.     purpose:    演示二叉树的算法
8. *********************************************************************/
10. #ifndef BinaryTree_H
11. #define BinaryTree_H
13. #include <stdlib.h>
14. #include <stack>
16. class BinaryTree
17. {
18. private:
19.     typedef int Item;
20.     typedef struct TreeNode
21.     {
22.         Item        Node;
23.         TreeNode*   pRight;
24.         TreeNode*   pLeft;
26.         TreeNode(Item node = 0, TreeNode* pright = NULL, TreeNode* pleft = NULL)
27.             : Node(node)
28.             , pRight(pright)
29.             , pLeft(pleft)
30.         {
31.         }
33.     }TreeNode, *PTreeNode;
35. public:
36.     enum TraverseType
37.     {
38.         PREORDER    = 0,        // 前序
39.         INORDER        = 1,        // 中序
40.         POSTORDER    = 2,        // 后序
41.         LEVELORDER    = 3            // 层序
42.     };
44.     BinaryTree(Item Array[], int nLength);
45.     ~BinaryTree();
47.     PTreeNode GetRoot()
48.     {
49.         return m_pRoot;
50.     }
52.     // 遍历树的对外接口
53.     // 指定遍历类型和是否是非递归遍历,默认是递归遍历
54.     void Traverse(TraverseType traversetype, bool bRec = true);
56. private:
57.     PTreeNode   CreateTreeImpl(Item Array[], int nLength);
58.     void        DetroyTreeImpl(PTreeNode pTreenode);
60.     void        PreTraverseImpl(PTreeNode pTreenode);        // 递归前序遍历树
61.     void        InTraverseImpl(PTreeNode pTreenode);        // 递归中序遍历树
62.     void        PostTraverseImpl(PTreeNode pTreenode);        // 递归后序遍历树
64.     void        NoRecPreTraverseImpl(PTreeNode pTreenode);    // 非递归前序遍历树
65.     void        NoRecInTraverseImpl(PTreeNode pTreenode);    // 非递归中序遍历树
66.     void        NoRecPostTraverseImpl(PTreeNode pTreenode);    // 非递归后序遍历树
68.     void        LevelTraverseImpl(PTreeNode pTreenode);
70.     PTreeNode   m_pRoot;        // 根结点
72.     // 采用STL里面的stack作为模拟保存链表结点的stack容器
73.     typedef std::stack<BinaryTree::PTreeNode> TreeNodeStack;
74. };
76. #endif

 

实现文件:

1. /********************************************************************
2.     created:    2006/07/04
3.     filename:     BinaryTree.cpp
4.     author:        李创
5.                 http://www.cppblog.com/converse/
7.     purpose:    演示二叉树的算法
8. *********************************************************************/
10. #include <iostream>
11. #include <assert.h>
12. #include <queue>
13. #include "BinaryTree.h"
15. BinaryTree::BinaryTree(Item Array[], int nLength)
16.     : m_pRoot(NULL)
17. {
18.     assert(NULL != Array);
19.     assert(nLength > 0);
21.     m_pRoot = CreateTreeImpl(Array, nLength);
22. }
24. BinaryTree::~BinaryTree()
25. {
26.     DetroyTreeImpl(m_pRoot);
27. }
29. // 按照中序递归创建树
30. BinaryTree::PTreeNode BinaryTree::CreateTreeImpl(Item Array[], int nLength)
31. {
32.     int mid = nLength / 2;
33.     PTreeNode p = new TreeNode(Array[mid]);
35.     if (nLength > 1)
36.     {
37.         p->pLeft    = CreateTreeImpl(Array, nLength / 2);
38.         p->pRight   = CreateTreeImpl(Array + mid + 1, nLength / 2 - 1);
39.     }
41.     return p;
42. }
44. void BinaryTree::DetroyTreeImpl(PTreeNode pTreenode)
45. {
46.     if (NULL != pTreenode->pLeft)
47.     {
48.         DetroyTreeImpl(pTreenode->pLeft);
49.     }
50.     if (NULL != pTreenode->pRight)
51.     {
52.         DetroyTreeImpl(pTreenode->pRight);
53.     }
55.     delete pTreenode;
56.     pTreenode = NULL;
57. }
59. // 遍历树的对外接口
60. // 指定遍历类型和是否是非递归遍历,默认是递归遍历
61. void BinaryTree::Traverse(TraverseType traversetype, bool bRec /**//*= true*/)
62. {
63.     switch (traversetype)
64.     {
65.     case PREORDER:    // 前序
66.         {            
67.             if (true == bRec)
68.             {
69.                 std::cout << "递归前序遍历树/n";
70.                 PreTraverseImpl(m_pRoot);
71.             }
72.             else
73.             {
74.                 std::cout << "非递归前序遍历树/n";
75.                 NoRecPreTraverseImpl(m_pRoot);
76.             }
77.         }
78.         break;
80.     case INORDER:    // 中序
81.         {            
82.             if (true == bRec)
83.             {
84.                 std::cout << "递归中序遍历树/n";
85.                 InTraverseImpl(m_pRoot);
86.             }
87.             else
88.             {
89.                 std::cout << "非递归中序遍历树/n";
90.                 NoRecInTraverseImpl(m_pRoot);
91.             }
92.         }
93.         break;
95.     case POSTORDER:    // 后序
96.         {            
97.             if (true == bRec)
98.             {
99.                 std::cout << "递归后序遍历树/n";
100.                 PostTraverseImpl(m_pRoot);
101.             }
102.             else
103.             {
104.                 std::cout << "非递归后序遍历树/n";
105.                 NoRecPostTraverseImpl(m_pRoot);
106.             }
107.         }
108.         break;
110.     case LEVELORDER:    // 层序
111.         {
112.             std::cout << "层序遍历树/n";
113.             LevelTraverseImpl(m_pRoot);
114.         }
115.     }
117.     std::cout << std::endl;
118. }
120. // 递归前序遍历树
121. void BinaryTree::PreTraverseImpl(PTreeNode pTreenode)
122. {
123.     if (NULL == pTreenode)
124.         return;
126.     std::cout << "Item = " << pTreenode->Node << std::endl;
128.     PreTraverseImpl(pTreenode->pLeft);
130.     PreTraverseImpl(pTreenode->pRight);
131. }
133. // 非递归前序遍历树
134. void BinaryTree::NoRecPreTraverseImpl(PTreeNode pTreenode)
135. {
136.     if (NULL == pTreenode)
137.         return;
139.     TreeNodeStack NodeStack;
140.     PTreeNode pNode;
141.     NodeStack.push(pTreenode);
143.     while (!NodeStack.empty())
144.     {
145.         while (NULL != (pNode = NodeStack.top()))    // 向左走到尽头
146.         {
147.             std::cout << "Item = " << pNode->Node << std::endl;    // 访问当前结点
148.             NodeStack.push(pNode->pLeft);                    // 左子树根结点入栈
149.         }
150.         NodeStack.pop();                                    // 左子树根结点退栈
151.         if (!NodeStack.empty())
152.         {
153.             pNode = NodeStack.top();
154.             NodeStack.pop();                                // 当前结点退栈
155.             NodeStack.push(pNode->pRight);                // 当前结点的右子树根结点入栈
156.         }
157.     }
158. }
160. // 中序遍历树
161. // 中序遍历输出的结果应该和用来初始化树的数组的排列顺序一致
162. void BinaryTree::InTraverseImpl(PTreeNode pTreenode)
163. {
164.     if (NULL == pTreenode)
165.         return;
167.     if (NULL != pTreenode->pLeft)
168.     {
169.         InTraverseImpl(pTreenode->pLeft);
170.     }
172.     std::cout << "Item = " << pTreenode->Node << std::endl;
174.     if (NULL != pTreenode->pRight)
175.     {
176.         InTraverseImpl(pTreenode->pRight);
177.     }
178. }
180. // 非递归中序遍历树
181. void BinaryTree::NoRecInTraverseImpl(PTreeNode pTreenode)
182. {
183.     if (NULL == pTreenode)
184.         return;
186.     TreeNodeStack NodeStack;
187.     PTreeNode pNode;
188.     NodeStack.push(pTreenode);
190.     while (!NodeStack.empty())
191.     {
192.         while (NULL != (pNode = NodeStack.top()))    // 向左走到尽头
193.         {
194.             NodeStack.push(pNode->pLeft);
195.         }
197.         NodeStack.pop();
199.         if (!NodeStack.empty() && NULL != (pNode = NodeStack.top()))
200.         {
201.             std::cout << "Item = " << pNode->Node << std::endl;
202.             NodeStack.pop();
203.             NodeStack.push(pNode->pRight);
204.         }
205.     }
206. }
208. // 后序遍历树
209. void BinaryTree::PostTraverseImpl(PTreeNode pTreenode)
210. {
211.     if (NULL == pTreenode)
212.         return;
214.     if (NULL != pTreenode->pLeft)
215.     {
216.         PostTraverseImpl(pTreenode->pLeft);
217.     }
219.     if (NULL != pTreenode->pRight)
220.     {
221.         PostTraverseImpl(pTreenode->pRight);
222.     }
224.     std::cout << "Item = " << pTreenode->Node << std::endl;
225. }
227. // 非递归后序遍历树
228. void BinaryTree::NoRecPostTraverseImpl(PTreeNode pTreenode)
229. {
230.     if (NULL == pTreenode)
231.         return;
233.     TreeNodeStack NodeStack;
234.     PTreeNode pNode1, pNode2;
235.     NodeStack.push(pTreenode);
236.     pNode1 = pTreenode->pLeft;
237.     
238.     bool bVisitRoot = false;            // 标志位,是否访问过根结点
239.     while (!NodeStack.empty())
240.     {
241.         while (NULL != pNode1)            // 向左走到尽头
242.         {
243.             NodeStack.push(pNode1);
244.             pNode1 = pNode1->pLeft;
245.         }
247.         pNode1 = NodeStack.top();
248.         NodeStack.pop();
250.         if (NULL == pNode1->pRight)            // 如果没有右子树就是叶子结点
251.         {
252.             std::cout << "Item = " << pNode1->Node << std::endl;
253.             pNode2 = pNode1;
254.             pNode1 = NodeStack.top();
256.             if (pNode2 == pNode1->pRight)    // 如果这个叶子结点是右子树
257.             {
258.                 std::cout << "Item = " << pNode1->Node << std::endl;
259.                 NodeStack.pop();
260.                 pNode1 = NULL;
261.             }
262.             else                            // 否则访问右子树
263.             {
264.                 pNode1 = pNode1->pRight;
265.             }
266.         }
267.         else                                // 访问右子树
268.         {
269.             if (pNode1 == pTreenode && true == bVisitRoot)    // 如果已经访问过右子树那么就退出
270.             {
271.                 std::cout << "Item = " << pNode1->Node << std::endl;
272.                 return;
273.             }
274.             else
275.             {
276.                 if (pNode1 == pTreenode)
277.                 {
278.                     bVisitRoot = true;
279.                 }
281.                 NodeStack.push(pNode1);
282.                 pNode1 = pNode1->pRight;
283.             }
284.         }
285.     }
286. }
288. // 按照树的层次从左到右访问树的结点
289. void BinaryTree::LevelTraverseImpl(PTreeNode pTreenode)
290. {
291.     if (NULL == pTreenode)
292.         return;
294.     // 层序遍历用于保存结点的容器是队列
295.     std::queue<PTreeNode> NodeQueue;
296.     PTreeNode pNode;
297.     NodeQueue.push(pTreenode);
299.     while (!NodeQueue.empty())
300.     {
301.         pNode = NodeQueue.front();
302.         NodeQueue.pop();
303.         std::cout << "Item = " << pNode->Node << std::endl;
305.         if (NULL != pNode->pLeft)
306.         {
307.             NodeQueue.push(pNode->pLeft);    
308.         }
309.         if (NULL != pNode->pRight)
310.         {
311.             NodeQueue.push(pNode->pRight);
312.         }    
313.     }
314. }

测试文件:

 

1. /********************************************************************
2.     created:    2006/07/04
3.     filename:     main.cpp
4.     author:        李创
5.                 http://www.cppblog.com/converse/
7.     purpose:    测试二叉树的算法
8. *********************************************************************/
10. #include "BinaryTree.h"
12. #include <stdio.h>
13. #include <stdlib.h>
14. #include <time.h>
15. #include <iostream>
17. void DisplayArray(int array[], int length)
18. {
19.     int i;
21.     for (i = 0; i < length; i++)
22.     {
23.         printf("array[%d] = %d/n", i, array[i]);
24.     }
25. }
27. void CreateNewArray(int array[], int length)
28. {
29.     for (int i = 0; i < length; i++)
30.     {
31.         array[i] = rand() % 256 + i;
32.     }
33. }
35. int main()
36. {
37.     int array[10];
38.     srand(time(NULL));
40.     // 创建数组
41.     CreateNewArray(array, 10);
42.     DisplayArray(array, 10);
44.     BinaryTree *pTree = new BinaryTree(array, 10);
46.     // 测试前序遍历
47.     pTree->Traverse(BinaryTree::PREORDER);
48.     std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
49.     std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
50.     std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
51.     pTree->Traverse(BinaryTree::PREORDER, false);
52.     
53.     // 测试中序遍历
54.     pTree->Traverse(BinaryTree::INORDER);
55.     std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
56.     std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
57.     std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
58.     pTree->Traverse(BinaryTree::INORDER, false);
59.     // 测试后序遍历
60.     pTree->Traverse(BinaryTree::POSTORDER);
61.     std::cout << "root = " << pTree->GetRoot()->Node << std::endl;
62.     std::cout << "root->left = " << pTree->GetRoot()->pLeft->Node << std::endl;
63.     std::cout << "root->right = " << pTree->GetRoot()->pRight->Node << std::endl;
64.     pTree->Traverse(BinaryTree::POSTORDER, false);
65.     // 测试层序遍历
66.     pTree->Traverse(BinaryTree::LEVELORDER);
68.     system("pause");
69.     
70.     delete pTree;
72.     return 0;
73. }