二叉树的遍历的应用

创建如下图所示的二叉树：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MAXSIZE 100
typedef char ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *lchild;
    struct Node *rchild;
}*BitTree,BitNode;
/*二叉树的基本操作*/
void InitBitTree(BitTree *T);//二叉树的初始化操作
void DestroyBitTree(BitTree *T);//销毁二叉树
void CreateBitTree(BitTree *T);//递归创建二叉树
void CreateBitTree2(BitTree *T,char str[]);//非递归创建二叉树
int InsertLeftChild(BitTree p,BitTree c);//二叉树的左插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的左子树，使p所指结点的左子树成为c的右子树
int InsertRightChild(BitTree p,BitTree c);//二叉树的右插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的右子树，使p所指结点的右子树成为c的右子树
BitTree Point(BitTree T,ElemType e);//返回二叉树结点的指针操作
ElemType LeftChild(BitTree T,ElemType e);//返回二叉树的结点的左孩子元素值操作
ElemType RightChild(BitTree T,ElemType e);//返回二叉树的结点的右孩子元素值操作
int DeleteLeftChild(BitTree p);//二叉树的左删除操作
int DeleteRightChild(BitTree p);//二叉树的右删除操作
void PreOrderTraverse(BitTree T);//先序遍历二叉树的递归实现
void InOrderTraverse(BitTree T);//中序遍历二叉树的递归实现
void PostOrderTraverse(BitTree T);//后序遍历二叉树的递归实现
void PostOrderTraverse2(BitTree T);//后序遍历二叉树的非递归实现
void PreOrderTraverse2(BitTree T);//先序遍历二叉树的非递归实现
void InOrderTraverse2(BitTree T);//中序遍历二叉树的非递归实现  

#include "LinkBiTree.h"
void InitBitTree(BitTree *T)//二叉树的初始化操作
{
    *T = NULL;
}
void DestroyBitTree(BitTree *T)//销毁二叉树
{
    if(*T)
    {
        if((*T)->lchild)
        {
            DestroyBitTree(&((*T)->lchild));
        }
        if((*T)->rchild)
        {
            DestroyBitTree(&((*T)->rchild));
        }
        free(*T);
        *T = NULL;
    }
}
void CreateBitTree(BitTree *T)//递归创建二叉树
{
    ElemType ch;
    scanf("%c",&ch);
    if(ch == '#')
    {
        *T = NULL;
    }
    else
    {
        *T = (BitTree)malloc(sizeof(BitNode));
        if(!(*T))
        {
            exit(-1);
        }
        else
        {
            (*T)->data = ch;
            CreateBitTree(&((*T)->lchild));
            CreateBitTree(&((*T)->rchild));
        }
    }
}
void CreateBitTree2(BitTree *T,char str[])//递归创建二叉树
{
    char ch;
    BitTree stack[MAXSIZE];
    int top = -1;
    int flag,k;
    BitNode *p;
    *T = NULL,k = 0;
    ch = str[k];
    while(ch != '\0')
    {
        switch(ch)
        {
        case '(':
                stack[++top] = p;
                flag = 1;
                break;
        case ')':
            top--;
            break;
        case ',':
            flag = 2;
            break;
        default:
            p = (BitTree)malloc(sizeof(BitNode));
            p->data = ch;
            p->lchild = NULL;
            p->rchild = NULL;
            if(*T == NULL)
            {
                *T = p;
            }
            else
            {
                switch(flag)
                {
                case 1:
                    stack[top]->lchild = p;
                    break;
                case 2:
                    stack[top]->rchild = p;
                    break;
                }
            }
        }
        ch = str[++k];
    }
}
int InsertLeftChild(BitTree p,BitTree c)//二叉树的左插入操作
{
    if(p)
    {
        c->rchild = p->lchild;
        p->lchild = c;
        return 1;
    }
    return 0;
}
int InsertRightChild(BitTree p,BitTree c)//二叉树的右插入操作
{
    if(p)
    {
        c->rchild = p->rchild ;
        p->rchild = c;
        return 1;
    }
    return 0;
}
BitTree Point(BitTree T,ElemType e)//返回二叉树结点的指针操作
{
    BitTree Q[MAXSIZE];
    int front = 0,rear = 0;
    BitNode *p;
    if(T)
    {
        Q[rear] = T;
        rear++;
        while(front != rear)
        {
            p = Q[front];
            front++;
            if(p->data == e)
            {
                return p;
            }
            if(p->lchild)
            {
                Q[rear] = p->lchild ;
                rear++;
            }
            if(p->rchild)
            {
                Q[rear] = p->rchild ;
                rear++;
            }
        }
    }
    return NULL;
}
ElemType LeftChild(BitTree T,ElemType e)//返回二叉树的结点的左孩子元素值操作
{
    BitTree p;
    if(T)
    {
        p = Point(T,e);
        if(p && p->lchild)
        {
            return p->lchild->data;
        }
    }
    exit(-1);
}
ElemType RightChild(BitTree T,ElemType e)//返回二叉树的结点的右孩子元素值操作
{
    BitTree p;
    if(T)
    {
        p = Point(T,e);
        if(p && p->rchild)
        {
            return p->rchild->data;
        }
    }
    exit(-1);
}
int DeleteLeftChild(BitTree p)//二叉树的左删除操作
{
    if(p)
    {
        DestroyBitTree(&(p->lchild));
        return 1;
    }
    return 0;
}
int DeleteRightChild(BitTree p)//二叉树的右删除操作
{
    if(p)
    {
        DestroyBitTree(&(p->rchild));
        return 1;
    }
    return 0;
}
void PreOrderTraverse(BitTree T)//先序遍历二叉树的递归实现
{
    if(T)
    {
        printf("%2c",T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
void InOrderTraverse(BitTree T)//中序遍历二叉树的递归实现
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        printf("%2c",T->data);
        InOrderTraverse(T->rchild);
    }
}
void PostOrderTraverse(BitTree T)//后序遍历二叉树的递归实现
{
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%2c",T->data);
    }
}
void PreOrderTraverse2(BitTree T)//后序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p;//定义一个结点指针
    top = 0;//初始化栈
    p = T;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            printf("%2c",p->data);//访问根结点
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[--top];//栈顶元素出栈
            p = p->rchild ;//遍历右子树
        }
    }
}
void InOrderTraverse2(BitTree T)//先序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p;//定义结点指针
    top = 0;//初始化栈
    p = T;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[--top];//栈顶元素出栈
            printf("%2c",p->data);//访问根结点
            p = p->rchild ;//遍历右子树
        }
    }
}
void PostOrderTraverse2(BitTree T)//中序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p,*q;//定义一个结点指针
    top = 0;//初始化栈
    p = T;
    q = NULL;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[top-1];//栈顶元素出栈
            if(p->rchild == NULL || p->rchild == q)
            {
                printf("%2c",p->data);//访问根结点
                q = p;
                p = NULL;
                top--;
            }
            else
            {
                p = p->rchild ;//遍历右子树
            }
        }
    }
}  

#include "LinkBiTree.h"  

int main(void)
{
    BitTree T,root;
    InitBitTree(&T);
    printf("根据输入二叉树的先序序列创建二叉树（‘#’表示结束）：\n");
    CreateBitTree(&T);
    printf("二叉树的先序序列：\n");
    printf("递归：");
    PreOrderTraverse(T);
    printf("\n");
    printf("非递归：");
    PreOrderTraverse2(T);
    printf("\n");
    printf("二叉树的中序序列：\n");
    printf("递归：");
    InOrderTraverse(T);
    printf("\n");
    printf("非递归：");
    InOrderTraverse2(T);
    printf("\n");
    printf("二叉树的后序序列：\n");
    printf("递归：");
    PostOrderTraverse(T);
    printf("\n");
    printf("非递归：");
    PostOrderTraverse2(T);
    printf("\n");
    printf("根据括号嵌套的字符串建立二叉树：\n");
    CreateBitTree2(&root,"(a(b(c,d),e(f,(,g),h(i))))");
    printf("二叉树的先序序列：\n");
    PreOrderTraverse(root);
    printf("\n");
    printf("二叉树的中序序列：\n");
    InOrderTraverse(root);
    printf("\n");
    printf("二叉树的后序序列：\n");
    PostOrderTraverse(root);
    printf("\n");
    DestroyBitTree(&T);
    DestroyBitTree(&root);
    return 0;
}

运行结果如图：

版权声明：本文为博主原创文章，未经博主允许不得转载。