二叉树三种遍历的非递归算法(背诵版)

　　1.先序遍历非递归算法

#define maxsize 100
typedef struct
{
    Bitree Elem[maxsize];
    int top;
}SqStack;

void PreOrderUnrec(Bitree t)
{
    SqStack s;
    StackInit(s);
    p=t;
    while (p!=null || !StackEmpty(s))
    {
        while (p!=null)            //遍历左子树
        {
            visite(p->data);
            push(s,p);
            p=p->lchild;     
        }//endwhile
       
        if (!StackEmpty(s))        //通过下一次循环中的内嵌while实现右子树遍历
        {
            p=pop(s);
            p=p->rchild;      
        }//endif           
    }//endwhile   
}//PreOrderUnrec
　2.中序遍历非递归算法

#define maxsize 100
typedef struct
{
    Bitree Elem[maxsize];
    int top;
}SqStack;

void InOrderUnrec(Bitree t)
{
    SqStack s;
    StackInit(s);
    p=t;
    while (p!=null || !StackEmpty(s))
    {
        while (p!=null)            //遍历左子树
        {
            push(s,p);
            p=p->lchild;
        }//endwhile
       
        if (!StackEmpty(s))
        {
            p=pop(s);
            visite(p->data);       //访问根结点
            p=p->rchild;           //通过下一次循环实现右子树遍历
        }//endif     
    }//endwhile
}//InOrderUnrec [NextPage]

　　3.后序遍历非递归算法

#define maxsize 100
typedef enum{L,R} tagtype;
typedef struct
{
    Bitree ptr;
    tagtype tag;
}stacknode;

typedef struct
{
    stacknode Elem[maxsize];
    int top;
}SqStack;

//后序遍历
void PostOrderUnrec(Bitree t)
{
    SqStack s;
    stacknode x;
    StackInit(s);
    p=t;
  
    do
    {
        while (p!=null)       //遍历左子树
        {
            x.ptr = p;
            x.tag = L;        //标记为左子树
            push(s,x);
            p=p->lchild;
        }
   
        while (!StackEmpty(s) &&s.Elem[s.top].tag==R) 
        {
            x = pop(s);
            p = x.ptr;
            visite(p->data);   //tag为R，表示右子树访问完毕，故访问根结点      
        }
       
        if (!StackEmpty(s))
        {
            s.Elem[s.top].tag =R;    //遍历右子树
           p=s.Elem[s.top].ptr->rchild;       
        }   
    }while (!StackEmpty(s));
}//PostOrderUnrec

　　4.层次遍历算法

　　// 二叉树的数据结构

structBinaryTree
{
    int value;    // 不写模板了，暂时用整形代替节点的数据类型
    BinaryTree *left;
    BinaryTree *right;
};
BinaryTree*root;    // 已知二叉树的根节点
//层次遍历
voidLevel( const BinaryTree *root )
{
    Queue *buf = new Queue();    // 定义一个空队列，假设此队列的节点数据类型也是整形的
    BinaryTree t;                // 一个临时变量
    buf.push_back(root);         //令根节点入队
    while( buf.empty == false )    // 当队列不为空
    {
        p = buf.front();          // 取出队列的第一个元素
        cout<<p->value<<' ';
        if( p->left != NULL )     // 若左子树不空，则令其入队
        {
            q.push( p->left );
        }
        if( p->right != NULL )    // 若右子树不空，则令其入队
        {
            q.push( p->right );
        }      
        buf.pop();              // 遍历过的节点出队
    }   
    cout<<endl;
}