二叉树的各种非递归遍历

1.前序非递归：

二叉树的非递归前序遍历，前序遍历思想：先让根进栈，只要栈不为空，就可以做弹出操作，  
每次弹出一个结点，记得把它的左右结点都进栈，记得右子树先进栈，这样可以保证右子树在栈中总处于左子树的下面。  
*/    
void PreOrder_Nonrecursive(BiTree T)     //先序遍历的非递归      
{    
    if(!T)      
        return ;      
      
    stack<BiTree> s;    
    s.push(T);    
    
    while(!s.empty())    
    {    
        BiTree temp = s.top();    
        cout<<temp->data<<" ";    
        s.pop();    
        if(temp->rchild)    
            s.push(temp->rchild);    
        if(temp->lchild)    
            s.push(temp->lchild);    
    }    
}    

2.中序非递归：

1. void InOrderTraverse(BiTree T)   // 中序遍历的非递归    
2. {    
3.     if(!T)    
4.         return ;    
5.     stack<BiTree> s;    
6.     BiTree curr = T->lchild;    // 指向当前要检查的节点    
7.     s.push(T);    
8.     while(curr != NULL || !s.empty())    
9.     {    
10.         while(curr != NULL)    // 一直向左走    
11.         {    
12.             s.push(curr);    
13.             curr = curr->lchild;    
14.         }    
15.         curr = s.top();    
16.         s.pop();    
17.         cout<<curr->data<<"  ";    
18.         curr = curr->rchild;    
19.     }    
20. }    
21.   

3。后序非递归：

1. void PostOrder_Nonrecursive(BiTree T)  // 后序遍历的非递归     双栈法    
2. {      
3.     stack<BiTree> s1 , s2;      
4.     BiTree curr ;           // 指向当前要检查的节点    
5.     s1.push(T);    
6.     while(!s1.empty())  // 栈空时结束      
7.     {    
8.         curr = s1.top();    
9.         s1.pop();    
10.         s2.push(curr);    
11.         if(curr->lchild)    
12.             s1.push(curr->lchild);    
13.         if(curr->rchild)    
14.             s1.push(curr->rchild);    
15.     }    
16.     while(!s2.empty())    
17.     {    
18.         printf("%c ", s2.top()->data);    
19.         s2.pop();    
20.     }    
21. }    

4. 层序遍历

1. int visit(BiTree T)    
2. {    
3.     if(T)    
4.     {    
5.         printf("%c ",T->data);    
6.         return 1;    
7.     }    
8.     else    
9.         return 0;    
10. }    

1. void LeverTraverse(BiTree T)   //方法一、非递归层次遍历二叉树     
2. {    
3.     queue <BiTree> Q;    
4.     BiTree p;    
5.     p = T;    
6.     if(visit(p)==1)    
7.         Q.push(p);    
8.     while(!Q.empty())    
9.     {    
10.         p = Q.front();    
11.         Q.pop();    
12.         if(visit(p->lchild) == 1)     
13.             Q.push(p->lchild);    
14.         if(visit(p->rchild) == 1)    
15.             Q.push(p->rchild);    
16.     }    
17. }