二叉树的先序中序后序遍历

1，分别写了先序遍历，中序遍历和后序遍历以及层次遍历的非递归算法！

[cpp]  view plain  copy

 

1. // 树的建立和遍历.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include <stack>  
6. #include <queue>  
7. #include <iostream>  
8. using namespace std;  
9.   
10. struct Node  
11. {  
12.     int data;  
13.     struct Node* left;  
14.     struct Node* right;  
15.     Node(int x):  
16.     data(x),left(NULL),right(NULL){}  
17. };  
18. //按先序遍历建树  
19. Node* createTree()  
20. {  
21.     int a;  
22.     cin >> a;  
23.     if (a == -1)  
24.     {  
25.         return NULL;  
26.     }  
27.     Node* root = new Node(a);  
28.     root->left = createTree();  
29.     root->right = createTree();  
30.     return root;  
31. }  
32. //先序非递归遍历  
33. void preorder(Node* root)  
34. {  
35.     if (root == NULL)  
36.     {  
37.         return;  
38.     }  
39.     stack<Node*> s;  
40.     while (root)  
41.     {  
42.         cout << root->data << ' ';  
43.         s.push(root);  
44.         root = root->left;//走到最左孩子  
45.     }  
46.     while (!s.empty())  
47.     {  
48.         Node* temp = s.top();//取栈顶元素  
49.         s.pop();//出栈  
50.         temp = temp->right;//看有没有右孩子  
51.         while (temp)  
52.         {  
53.             cout << temp->data << ' ';  
54.             s.push(temp);  
55.             temp = temp->left;  
56.         }  
57.     }  
58.     cout << endl;  
59. }  
60. //中序遍历非递归算法  
61. void inorder(Node* root)  
62. {  
63.     if (root == NULL)  
64.     {  
65.         return;  
66.     }  
67.     stack<Node*> s;  
68.     while (root)  
69.     {  
70.         s.push(root);  
71.         root = root->left;//进栈到最左孩子  
72.     }  
73.     while (!s.empty())  
74.     {  
75.         Node* temp = s.top();  
76.         cout << temp->data << ' ';  
77.         s.pop();//出栈，看右孩子  
78.         temp = temp->right;  
79.         while (temp)  
80.         {  
81.             s.push(temp);  
82.             temp = temp->left;  
83.         }  
84.     }  
85.     cout << endl;  
86. }  
87. //后序遍历非递归算法  
88. void postorder(Node* root)  
89. {  
90.     if (root == NULL)  
91.     {  
92.         return;  
93.     }  
94.     stack<Node*> s;  
95.     Node* previsited = NULL;//记录刚被访问的节点  
96.     while (root)  
97.     {  
98.         s.push(root);  
99.         root = root->left;  
100.     }  
101.     while (!s.empty())  
102.     {  
103.         Node* temp = s.top();  
104.         if (temp->right == NULL || temp->right == previsited)  
105.         {  
106.             cout << temp->data << ' ';  
107.             s.pop();  
108.             previsited = temp;  
109.         }  
110.         else  
111.         {  
112.             temp = temp->right;//找到右孩子，  
113.             while (temp)  
114.             {  
115.                 s.push(temp);  
116.                 temp = temp->left;  
117.             }  
118.         }  
119.     }  
120.     cout << endl;  
121. }  
122. //层次遍历二叉树，按层次输出  
123. void leveltraver(Node* root)  
124. {  
125.     if (root == NULL)  
126.     {  
127.         return;  
128.     }  
129.     queue<Node*> q;  
130.     q.push(root);  
131.     while (!q.empty())  
132.     {  
133.         int length = q.size();  
134.         while (length--)  
135.         {  
136.             Node* temp = q.front();  
137.             cout << temp->data << ' ';  
138.             q.pop();  
139.             if (temp->left != NULL)  
140.             {  
141.                 q.push(temp->left);  
142.             }  
143.             if (temp->right != NULL)  
144.             {  
145.                 q.push(temp->right);  
146.             }  
147.         }  
148.         cout << endl;  
149.     }  
150.     cout << endl;  
151. }  
152. int _tmain(int argc, _TCHAR* argv[])  
153. {  
154.     cout << "输入数据先序建树：" << endl;  
155.     Node* root = createTree();  
156.     cout << "先序遍历为：" << endl;  
157.     preorder(root);  
158.     cout << "中序遍历为：" << endl;  
159.     inorder(root);  
160.     cout << "后序遍历为：" << endl;  
161.     postorder(root);  
162.     cout << "层次遍历为：" << endl;  
163.     leveltraver(root);  
164.     system("pause");  
165.     return 0;  
166. }  

输入和输出为：

二叉树的三种基本遍历非递归算法都可以用栈来实现，共同的操作时从根开始入栈，一直到最左孩子为止。

不同的是在出栈前访问，还是在进栈到最左孩子后，出栈时访问，还是在访问时要加条件判断！！！