二叉树的链式存储

最新推荐文章于 2025-02-03 23:55:41 发布
为爱坚持
最新推荐文章于 2025-02-03 23:55:41 发布
阅读量927
点赞数 1
CC 4.0 BY-SA版权
分类专栏：数据结构文章标签：二叉树链式存储
本文链接：https://blog.youkuaiyun.com/weichanjuan3/article/details/47091323
数据结构专栏收录该内容
45 篇文章
订阅专栏
本文详细介绍了二叉树的初始化、销毁、创建、插入、删除、以及先序、中序、后序遍历等核心操作，并提供了递归和非递归两种实现方式。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
#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 ;//遍历右子树  
            }  
        }  
    }  
}