二叉树的递归和非递归遍历

递归遍历简单明了，不罗嗦，非递归形式可以使用堆栈实现。

[cpp]  view plain copy

1. //前序遍历 递归方式  
2. void preorder1(BSTreeNode *pNode)  
3. {  
4.     if(pNode==NULL)  
5.         return;  
6.     cout<<pNode->m_value<<" ";  
7.     preorder1(pNode->m_pleft);  
8.     preorder1(pNode->m_pright);  
9. }  
10. //前序遍历 非递归方式  
11. void preorder2(BSTreeNode *pNode)  
12. {  
13.     if(pNode==NULL)  
14.         return;  
15.     stack<BSTreeNode *> bstStack;  
16.     bstStack.push(pNode);  
17.     while (!bstStack.empty())  
18.     {  
19.         BSTreeNode *pNode=bstStack.top();  
20.         bstStack.pop();  
21.         cout<<pNode->m_value<<" ";  
22.   
23.         if (pNode->m_pright!=NULL)  
24.             bstStack.push(pNode->m_pright);  
25.   
26.         if (pNode->m_pleft!=NULL)  
27.             bstStack.push(pNode->m_pleft);  
28.   
29.   
30.     }  
31. }  

前序遍历是典型的尾递归，很好消除，对于后序遍历和中序遍历的实现就稍微复杂一些了，需要附加变量来记录是否访问过。在二叉树结构体中添加 bool    m_bvisit;

后序遍历，中序遍历的实现代码。

[cpp]  view plain copy

1. //后序遍历 递归  
2. void postorder1(BSTreeNode *pNode)  
3. {  
4.     if(pNode==NULL)  
5.         return;  
6.   
7.     postorder1(pNode->m_pleft);  
8.     postorder1(pNode->m_pright);  
9.   
10.     cout<<pNode->m_value<<" ";  
11. }  
12. //后序遍历  非递归  
13. void postorder2(BSTreeNode *pNode)  
14. {  
15.     if(pNode==NULL)  
16.         return;  
17.     SetUnvisited(pNode);    //将所有节点设置为未访问  
18.     stack<BSTreeNode *> bstStack;  
19.     bstStack.push(pNode);  
20.     while (!bstStack.empty())  
21.     {  
22.         BSTreeNode *pNode=bstStack.top();  
23.   
24.         if (pNode->m_pleft!=NULL&&pNode->m_pleft->m_bvisit==false)     //存在左子树，并且未访问  
25.             bstStack.push(pNode->m_pleft);  
26.         else if(pNode->m_pright!=NULL&&pNode->m_pright->m_bvisit==false)   //存在右子树，并且未访问  
27.             bstStack.push(pNode->m_pright);  
28.         else                            //不存在左右子树，或都已经访问  
29.         {  
30.             bstStack.pop();  
31.             cout<<pNode->m_value<<" ";  
32.             pNode->m_bvisit=true;  
33.         }  
34.     }  
35. }  
36.   
37.   
38. //中序遍历 递归  
39. void inorder1(BSTreeNode *pNode)  
40. {  
41.     if(pNode==NULL)  
42.         return;  
43.   
44.     inorder1(pNode->m_pleft);  
45.     cout<<pNode->m_value<<" ";  
46.     inorder1(pNode->m_pright);  
47.   
48. }  
49. //中序遍历  非递归  
50. void inorder2(BSTreeNode *pNode)  
51. {  
52.     if(pNode==NULL)  
53.         return;  
54.     SetUnvisited(pNode);    //将所有节点设置为未访问  
55.     stack<BSTreeNode *> bstStack;  
56.     bstStack.push(pNode);  
57.     while (!bstStack.empty())  
58.     {  
59.         BSTreeNode *pNode=bstStack.top();  
60.   
61.         if (pNode->m_pleft!=NULL&&pNode->m_pleft->m_bvisit==false)     //存在左子树，并且未访问  
62.             bstStack.push(pNode->m_pleft);  
63.         else                                                        //不存在左子树，或已访问  
64.         {         
65.             if(pNode->m_bvisit==false)                   //当前节点未访问  
66.             {  
67.                 cout<<pNode->m_value<<" ";  
68.                 pNode->m_bvisit=true;  
69.             }  
70.   
71.             if(pNode->m_pright!=NULL&&pNode->m_pright->m_bvisit==false)        //存在右子树，并且未访问  
72.                 bstStack.push(pNode->m_pright);  
73.             else            //不存在左右子树，或都已经访问  
74.             {  
75.                 bstStack.pop();  
76.             }  
77.         }  
78.     }  
79. }