数据结构与算法之二叉树的遍历方式

在二叉树的一些应用中，常常要求在数中查找具有某种特征的结点，或者对树中全部结点逐一进行某种处理。这就提出了一个遍历二叉树（traversing binary tree）的问题。

其中限定先左后右的情况下，只有三种情况，分别称之为先序遍历，中序遍历，后序遍历。

先序遍历二叉树的定义为：

若二叉树为空，则空操作；否则

（1）访问根结点；

（2）先序遍历左子树；

（3）后序遍历右子树；

 

中序遍历二叉树的定义为：

若二叉树为空，则空操作；否则

（1）中序遍历左子树；

（2）访问根结点；

（3）中序遍历右子树；

 

后序遍历二叉树的定义为：

若二叉树为空，则空操作；否则

 

（1）后序遍历左子树；

（2）后序遍历右子树；

（3）访问根结点；

 

代码如下：（递归）

#include <stdio.h>
#include <stdlib.h>

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW    -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef int Status;
typedef char TElemType;

/***********存储树的栈的结构*************/
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;

typedef BiTree SElemType;

typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
} SqStack;

Status InitStack(SqStack &S)
{
    S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status Push(SqStack &S, SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base = (SElemType *)realloc
                 (S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base) exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return OK;
}

Status Pop(SqStack &S, SElemType &e)
{
    if(S.top == S.base) return ERROR;
    e = *--S.top;
    return OK;
}

Status StackEmpty(SqStack S)
{
    if(S.base == S.top)
        return TRUE;
    return FALSE;
}
/***************分界线******************/
Status CreateBiTree(BiTree &T)
{
    ///按先序次序输入二叉树中的结点，空格表示空树
    ///生成二叉树的二叉链表存储结构，T为根结点指针
    char ch;

    scanf("%c",&ch);
    if(ch == ' ') T=NULL;
    else
    {
        if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
        T->data=ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return OK;
}

Status PrintElement(TElemType e)
{
    printf("%c",e);
    return OK;
}

Status PreorderTraverse(BiTree T, Status(*visit)(TElemType e))
{
    ///先序遍历根结点，指针为T的二叉树

    if(T)
    {
        if(visit(T->data))
            if(PreorderTraverse(T->lchild,visit))
                if(PreorderTraverse(T->rchild,visit))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}

Status InorderTraverse1(BiTree T, Status(*visit)(TElemType e))
{
    ///中序遍历根结点，指针为T的二叉树

    if(T)
    {
        if(PreorderTraverse(T->lchild,visit))
            if(visit(T->data))
                if(PreorderTraverse(T->rchild,visit))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}

Status PostorderTraverse(BiTree T, Status(*visit)(TElemType e))
{
    ///后序遍历根结点，指针为T的二叉树

    if(T)
    {
        if(PreorderTraverse(T->lchild,visit))
            if(PreorderTraverse(T->rchild,visit))
                if(visit(T->data))
                    return OK;
        return ERROR;
    }
    else
        return OK;
}

Status InorderTraverse2(BiTree T,Status(*visit)(TElemType e))
{
    ///中序遍历非递归算法遍历二叉树

    SqStack S;
    InitStack(S);
    BiTree p=T;
    while( p || !StackEmpty(S))
    {
        ///找到最左下的结点
        if(p)
        {
            Push(S,p);
            p=p->lchild;
        }
        else
        {
            Pop(S,p);
            if(!visit(p->data)) return ERROR;
            p=p->rchild;
        }
    }
    return OK;
}

int main()
{
    BiTree T;

    printf("Please input characters to create a tree.\n");
    CreateBiTree(T);

    printf("Preorder traverse the tree:\n");
    PreorderTraverse(T,PrintElement);

    printf("\nInorder traverse the tree:digui\n");
    InorderTraverse1(T,PrintElement);
    printf("\nInorder traverse the tree:fei digui\n");
    InorderTraverse2(T,PrintElement);
    printf("\nPostorder traverse the tree:\n");
    PostorderTraverse(T,PrintElement);
    return 0;
}