数据结构学习笔记（三） 树形结构之前、中、后序遍历（非递归）

以下是以非递归方法遍历二叉树的代码实现，包括前序遍历、中序遍历以及后序遍历。
遍历所用的二叉树图示如下：

一、前序遍历。

#include
using namespace std;

//抽象数据类型——变量定义和变量说明
const int MaxSize=10;
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
}BTnode,*BinTree;
typedef struct
{
    BTnode* S[MaxSize];
    int top;
}SeqStack;
SeqStack ST;
BTnode *p;

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,BTnode *p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<else
        ST.S[++ST.top]=p;
}

//栈的弹出
BTnode* pop(SeqStack &ST,BTnode *p)
{
    if(ST.top==-1)
        cout<<"underflow!"<else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack &ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树
void Create(BinTree &root)
{
    BTnode *A=new BTnode;
    BTnode *B=new BTnode;
    BTnode *C=new BTnode;
    BTnode *D=new BTnode;
    BTnode *E=new BTnode;
    BTnode *F=new BTnode;
    BTnode *G=new BTnode;
    BTnode *H=new BTnode;
    BTnode *I=new BTnode;
    BTnode *J=new BTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;

    B->lchild=D;
    B->rchild=E;

    E->lchild=H;
    E->rchild=I;

    C->lchild=F;
    C->rchild=G;

    F->lchild=NULL;
    F->rchild=J;

    D->lchild=D->rchild=NULL;
    H->lchild=H->rchild=NULL;
    I->lchild=I->rchild=NULL;
    J->lchild=J->rchild=NULL;
    G->lchild=G->rchild=NULL;

    root=A;
}

//前序遍历二叉树的非递归算法
void preOrder(BinTree &root)
{
    ClearStack(ST);
    p=root;
    while((p!=NULL)||(!StackEmpty(ST)))
    {
        if(p!=NULL)
        {
            cout<data)<<" ";
            push(ST,p);
            p=p->lchild;
        }
        else
        {
            p=pop(ST,p);
            p=p->rchild;
        }
    }
}

//测试函数
int main()
{
    BinTree root;
    Create(root);
    preOrder(root);
    return 0;
}

二、中序遍历。

//使用课本p105底部二叉树
#include
using namespace std;

//抽象数据类型——变量定义和变量说明
const int MaxSize=10;
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
}BTnode,*BinTree;
typedef struct
{
    BTnode* S[MaxSize];
    int top;
}SeqStack;
SeqStack ST;
BTnode *p;

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,BTnode *p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<else
        ST.S[++ST.top]=p;
}

//栈的弹出
BTnode* pop(SeqStack &ST,BTnode *p)
{
    if(ST.top==-1)
        cout<<"underflow!"<else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack &ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树课本p105
void Create(BinTree &root)
{
    BTnode *A=new BTnode;
    BTnode *B=new BTnode;
    BTnode *C=new BTnode;
    BTnode *D=new BTnode;
    BTnode *E=new BTnode;
    BTnode *F=new BTnode;
    BTnode *G=new BTnode;
    BTnode *H=new BTnode;
    BTnode *I=new BTnode;
    BTnode *J=new BTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;

    B->lchild=D;
    B->rchild=E;

    E->lchild=H;
    E->rchild=I;

    C->lchild=F;
    C->rchild=G;

    F->lchild=NULL;
    F->rchild=J;

    D->lchild=D->rchild=NULL;
    H->lchild=H->rchild=NULL;
    I->lchild=I->rchild=NULL;
    J->lchild=J->rchild=NULL;
    G->lchild=G->rchild=NULL;

    root=A;
}

//中序遍历二叉树的非递归算法
void inOrder(BinTree &root)
{
    ClearStack(ST);
    p=root;
    while((p!=NULL)||(!StackEmpty(ST)))
    {
        if(p!=NULL)
        {
            push(ST,p);
            p=p->lchild;
        }
        else
        {
            p=pop(ST,p);
            cout<<char(p->data)<<" ";
            p=p->rchild;
        }
    }
}

//测试函数
int main()
{
    BinTree root;
    Create(root);
    cout<<"中序遍历结果为："<return 0;
}

三、后序遍历。

//使用课本p105底部二叉树
#include
using namespace std;

//抽象数据类型——变量定义和变量说明
const int MaxSize=10;
typedef char datatype;
typedef struct node
{
    datatype data;
    struct node *lchild,*rchild;
}BTnode,*BinTree;

typedef struct
{
    enum{L,R} tag;
    BTnode *ptr;
}element;

typedef struct
{
    element S[MaxSize];
    int top;
}SeqStack;

SeqStack ST;
BTnode *p;

//置空栈
void ClearStack(SeqStack &ST)
{
    ST.top=-1;
}

//栈的推入
void push(SeqStack &ST,element p)
{
    if(ST.top>=MaxSize-1)
        cout<<"overflow!"<else
        ST.S[++ST.top]=p;
}

//栈的弹出
element pop(SeqStack &ST,element p)
{
    if(ST.top==-1)
        cout<<"underflow!"<else
        p=ST.S[ST.top--];
    return p;
}

//判栈空否
int StackEmpty(SeqStack &ST)
{
    if(ST.top==-1)
        return 1;
    else
        return 0;
}

//构建一棵二叉树课本p105
void Create(BinTree &root)
{
    BTnode *A=new BTnode;
    BTnode *B=new BTnode;
    BTnode *C=new BTnode;
    BTnode *D=new BTnode;
    BTnode *E=new BTnode;
    BTnode *F=new BTnode;
    BTnode *G=new BTnode;
    BTnode *H=new BTnode;
    BTnode *I=new BTnode;
    BTnode *J=new BTnode;

    A->data='A';
    B->data='B';
    C->data='C';
    D->data='D';
    E->data='E';
    F->data='F';
    G->data='G';
    H->data='H';
    I->data='I';
    J->data='J';

    A->lchild=B;
    A->rchild=C;

    B->lchild=D;
    B->rchild=E;

    E->lchild=H;
    E->rchild=I;

    C->lchild=F;
    C->rchild=G;

    F->lchild=NULL;
    F->rchild=J;

    D->lchild=D->rchild=NULL;
    H->lchild=H->rchild=NULL;
    I->lchild=I->rchild=NULL;
    J->lchild=J->rchild=NULL;
    G->lchild=G->rchild=NULL;

    root=A;
}

//后序遍历二叉树的非递归算法
void postOrder(BinTree &root)
{
    element w;
    ClearStack(ST);
    p=root;
    while((p!=NULL)||(!StackEmpty(ST)))
    {
        if(p!=NULL)
        {
            w.ptr=p;
            w.tag=L;
            push(ST,w);
            p=p->lchild;
        }
        else
        {
            w=pop(ST,w);
            p=w.ptr;
            if(w.tag==L)
            {
                w.tag=R;
                push(ST,w);
                p=p->rchild;
            }
            else
            {
                cout<<char(p->data)<<" ";
                p=NULL;
            }
        }
    }
}

//测试函数
int main()
{
    BinTree root;
    Create(root);
    cout<<"后序遍历结果为："<return 0;
}