数据结构-二叉树

以下为二叉树的各种遍历的C语言实现程序，包括先序、中序、后序遍历（递归和非递归实现）和层次遍历。

  1 #include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<stack>
#include<queue>
using namespace std;

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;

int CreateBiTree(BiTree &T)
{//按先序序列创建二叉树
    char ch;
    scanf("%c",&ch);
    if(ch =='&')//‘ ’表示空树
    {
        T = NULL;
    }
    else
    {
        T = (BiTree)malloc(sizeof(BiTNode));
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
    return 0;
}

void Visit(BiTree T)
{
    if(T->data != ' ')
    {
        printf("%c ",T->data);
    }
}

void PreOrder(BiTree T)
{//先序遍历
    if(T!= NULL)
    {
        Visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

void InOrder(BiTree T)
{//中序遍历
    if(T!= NULL)
    {
        InOrder(T->lchild);
        Visit(T);
        InOrder(T->rchild);
    }
}

void PostOrder(BiTree T)
{//后序遍历
    if(T!= NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        Visit(T);
    }
}

void PreOrder2(BiTree T)
{//先序遍历(非递归).访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;
    while(p || !stack.empty())
    {//栈不空或p不空时循环
        if(p != NULL)
        {
            stack.push(p);
            printf("%c ",p->data);//访问根节点
            p = p->lchild;//遍历左子树
        }
        else
        {
            p = stack.top();
            stack.pop();//退栈
            p = p->rchild;//访问右子树
        }
    }//while
}

void InOrder2(BiTree T)
{// 中序遍历(非递归).中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
  //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
    stack<BiTree> stack;
    BiTree p = T;//p是遍历指针
    while(p || !stack.empty())
    {//栈不空或者p不空时循环
        if(p != NULL)
        {
            stack.push(p);//入栈
            p = p->lchild;//遍历左子树
        }
        else
        {
            p = stack.top();//退栈，访问根节点
            printf("%c ",p->data);
            stack.pop();
            p = p->rchild;//访问右子树
        }
    }
}

typedef struct BiTNodePost
{
    BiTree biTree;
    char tag;
} BiTNodePost,*BiTreePost;

void PostOrder2(BiTree T)
{//后序遍历(非递归).
    stack<BiTreePost> stack;
    BiTree p = T;
    BiTreePost BT;
    while(p != NULL || !stack.empty())
    {
        while(p != NULL)
        {//遍历左子树
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            BT->tag = 'L';//访问过左子树
            stack.push(BT);
            p = p->lchild;
        }
        while(!stack.empty() && (stack.top())->tag == 'R')
        { //左右子树访问完毕访问根节点
            BT = stack.top();
            stack.pop();//退栈
            printf("%c ",BT->biTree->data);
        }
        if(!stack.empty())//遍历右子树
        {
            BT = stack.top();
            BT->tag = 'R'; //访问过右子树
            p = BT->biTree;
            p = p->rchild;
        }
    }
}

void LevelOrder(BiTree T)
{//层次遍历
    BiTree p = T;
    queue<BiTree> queue;//队列
    queue.push(p);//根节点入队
    while(!queue.empty())
    {//队列不空循环
        p = queue.front();//对头元素出队
        printf("%c ",p->data);//访问p指向的结点

        queue.pop();//退出队列
        if(p->lchild != NULL)
        {//左子树不空，将左子树入队
            queue.push(p->lchild);
        }
        if(p->rchild != NULL)
        { //右子树不空，将右子树入队
            queue.push(p->rchild);
        }
    }
}
int main()
{
    BiTree T;
    printf("请输入示例先序序列:ABDH&&&E&I&&CF&G&&&.或者自定义先序序列.\n");
    CreateBiTree(T);

    printf("\n---------------------------\n");
    printf("先序遍历：\n");
    PreOrder(T);

    printf("\n---------------------------\n");
    printf("先序遍历(非递归)：\n");
    PreOrder2(T);

    printf("\n---------------------------\n");
    printf("中序遍历：\n");
    InOrder(T);

    printf("\n---------------------------\n");
    printf("中序遍历(非递归)：\n");
    InOrder2(T);

    printf("\n---------------------------\n");
    printf("后序遍历：\n");
    PostOrder(T);

    printf("\n---------------------------\n");
    printf("后序遍历(非递归)：\n");
    PostOrder2(T);

    printf("\n---------------------------\n");
    printf("层次遍历：\n");
    LevelOrder(T);
    printf("\n---------------------------\n");
    return 0;
}