一.前序遍历
非递归实现
根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：
对于任一结点P：
1)访问结点P，并将结点P入栈;
2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。
1 void preOrder2(BinTree *root) //非递归前序遍历
2 {
3 stack
4 BinTree *p=root;
5 while(p!=NULL||!s.empty())
6 {
7 while(p!=NULL)
8 {
9 cout<
10 s.push(p);
11 p=p->lchild;
12 }
13 if(!s.empty())
14 {
15 p=s.top();
16 s.pop();
17 p=p->rchild;
18 }
19 }
20 }
二.中序遍历
非递归实现
根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：
对于任一结点P，
1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
3)直到P为NULL并且栈为空则遍历结束。
1 void inOrder2(BinTree *root) //非递归中序遍历
2 {
3 stack
4 BinTree *p=root;
5 while(p!=NULL||!s.empty())
6 {
7 while(p!=NULL)
8 {
9 s.push(p);
10 p=p->lchild;
11 }
12 if(!s.empty())
13 {
14 p=s.top();
15 cout<
16 s.pop();
17 p=p->rchild;
18 }
19 }
20 }
三.后序遍历
非递归实现
第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就 保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。
1 void postOrder2(BinTree *root) //非递归后序遍历
2 {
3 stack
4 BinTree *p=root;
5 BTNode *temp;
6 while(p!=NULL||!s.empty())
7 {
8 while(p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的结点
9 {
10 BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
11 btn->btnode=p;
12 btn->isFirst=true;
13 s.push(btn);
14 p=p->lchild;
15 }
16 if(!s.empty())
17 {
18 temp=s.top();
19 s.pop();
20 if(temp->isFirst==true) //表示是第一次出现在栈顶
21 {
22 temp->isFirst=false;
23 s.push(temp);
24 p=temp->btnode->rchild;
25 }
26 else //第二次出现在栈顶
27 {
28 cout<
29 p=NULL;
30 }
31 }
32 }
33 }
第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存 在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
1 void postOrder3(BinTree *root)
//非递归后序遍历
2 {
3 stack
4 BinTree *cur; //当前结点
5 BinTree *pre=NULL; //前一次访问的结点
6 s.push(root);
7 while(!s.empty())
8 {
9 cur=s.top();
10if((cur->lchild==NULL&&cur- >rchild==NULL)||
11 (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
12 {
13 cout<
//如果当前结点没有孩子结点或者孩子节点都已被访问过
14 s.pop();
15 pre=cur;
16 }
17 else
18 {
19 if(cur->rchild!=NULL)
20 s.push(cur->rchild);
21 if(cur->lchild!=NULL)
22 s.push(cur->lchild);
23 }
24 }
25 }
四.整个程序完整的代码
1 /*二叉树的遍历* 2011.8.25*/
2
3 #include
4 #include
5 #include
6 using namespace std;
7
8 typedef struct node
9 {
10 char data;
11 struct node *lchild,*rchild;
12 }BinTree;
13
14 typedef struct node1
15 {
16 BinTree *btnode;
17 bool isFirst;
18 }BTNode;
19
20
21 void creatBinTree(char *s,BinTree *&root) //创建二叉树，s为形如A(B,C(D,E))形式的字符串
22 {
23 int i;
24 bool isRight=false;
25 stack
26 stack
27 BinTree *p,*temp;
28 root->data=s[0];
29 root->lchild=NULL;
30 root->rchild=NULL;
31 s1.push(root);
32 i=1;
33 while(i 34 { 35 if(s[i]=='(') 36 { 37 s2.push(s[i]); 38 isRight=false; 39 } 40 else if(s[i]==',') 41 { 42 isRight=true; 43 } 44 else if(s[i]==')') 45 { 46 s1.pop(); 47 s2.pop(); 48 } 49 else if(isalpha(s[i])) 50 { 51 p=(BinTree *)malloc(sizeof(BinTree)); 52 p->data=s[i]; 53 p->lchild=NULL; 54 p->rchild=NULL; 55 temp=s1.top(); 56 if(isRight==true) 57 { 58 temp->rchild=p; 59 cout< 60 } 61 else 62 { 63 temp->lchild=p; 64 cout< 65 } 66 if(s[i+1]=='(') 67 s1.push(p); 68 } 69 i++; 70 } 71 } 72 73 void display(BinTree *root) //显示树形结构 74 { 75 if(root!=NULL) 76 { 77 cout< 78 if(root->lchild!=NULL) 79 { 80 cout<<'('; 81 display(root->lchild); 82 } 83 if(root->rchild!=NULL) 84 { 85 cout<<','; 86 display(root->rchild); 87 cout<<')'; 88 } 89 } 90 } 91 92 void preOrder1(BinTree *root) //递归前序遍历 93 { 94 if(root!=NULL) 95 { 96 cout< 97 preOrder1(root->lchild); 98 preOrder1(root->rchild); 99 } 100 } 101 102 void inOrder1(BinTree *root) //递归中序遍历 103 { 104 if(root!=NULL) 105 { 106 inOrder1(root->lchild); 107 cout< 108 inOrder1(root->rchild); 109 } 110 } 111 112 void postOrder1(BinTree *root) //递归后序遍历 113 { 114 if(root!=NULL) 115 { 116 postOrder1(root->lchild); 117 postOrder1(root->rchild); 118 cout< 119 } 120 } 121 122 void preOrder2(BinTree *root) //非递归前序遍历 123 { 124 stack 125 BinTree *p=root; 126 while(p!=NULL||!s.empty()) 127 { 128 while(p!=NULL) 129 { 130 cout< 131 s.push(p); 132 p=p->lchild; 133 } 134 if(!s.empty()) 135 { 136 p=s.top(); 137 s.pop(); 138 p=p->rchild; 139 } 140 } 141 } 142 143 void inOrder2(BinTree *root) //非递归中序遍历 144 { 145 stack 146 BinTree *p=root; 147 while(p!=NULL||!s.empty()) 148 { 149 while(p!=NULL) 150 { 151 s.push(p); 152 p=p->lchild; 153 } 154 if(!s.empty()) 155 { 156 p=s.top(); 157 cout< 158 s.pop(); 159 p=p->rchild; 160 } 161 } 162 } 163 164 void postOrder2(BinTree *root) //非递归后序遍历 165 { 166 stack 167 BinTree *p=root; 168 BTNode *temp; 169 while(p!=NULL||!s.empty()) 170 { 171 while(p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的结点 172 { 173 BTNode *btn=(BTNode *)malloc(sizeof(BTNode)); 174 btn->btnode=p; 175 btn->isFirst=true; 176 s.push(btn); 177 p=p->lchild; 178 } 179 if(!s.empty()) 180 { 181 temp=s.top(); 182 s.pop(); 183 if(temp->isFirst==true) //表示是第一次出现在栈顶 184 { 185 temp->isFirst=false; 186 s.push(temp); 187 p=temp->btnode->rchild; 188 } 189 else //第二次出现在栈顶 190 { 191 cout< 192 p=NULL; 193 } 194 } 195 } 196 } 197 198 void postOrder3(BinTree *root) //非递归后序遍历 199 { 200 stack 201 BinTree *cur; //当前结点 202 BinTree *pre=NULL; //前一次访问的结点 203 s.push(root); 204 while(!s.empty()) 205 { 206 cur=s.top(); 207 if((cur->lchild==NULL&&cur->rchild==NULL)|| 208 (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild))) 209 { 210 cout< 211 s.pop(); 212 pre=cur; 213 } 214 else 215 { 216 if(cur->rchild!=NULL) 217 s.push(cur->rchild); 218 if(cur->lchild!=NULL) 219 s.push(cur->lchild); 220 } 221 } 222 } 223 224 225 int main(int argc, char *argv[]) 226 { 227 char s[100]; 228 while(scanf("%s",s)==1) 229 { 230 BinTree *root=(BinTree *)malloc(sizeof(BinTree)); 231 creatBinTree(s,root); 232 display(root); 233 cout< 234 preOrder2(root); 235 cout< 236 inOrder2(root); 237 cout< 238 postOrder2(root); 239 cout< 240 postOrder3(root); 241 cout< 242 } 243 return 0; 244 }