二叉树的各种操作

最新推荐文章于 2022-11-04 15:01:27 发布
最新推荐文章于 2022-11-04 15:01:27 发布
阅读量920 收藏
点赞数
分类专栏： 算法&数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/celte/article/details/27382963
版权

数据结构实验，主要是对二叉树的各种操作方法。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TRUE  1
#define FALSE 0
#define maxsize 100
typedef struct TreeNode
{
    char data;
    struct TreeNode *left;
    struct TreeNode *right;
    int visit;//在遍历的时候用于标记此结点的左右结点是否都已经访问过
}TreeNode,BinaryTree;


//void CreateBiTree(BinaryTree **T,char *definition);//创建树
void CreateBiTree(BinaryTree **T);//创建树
int EditTreeNode(BinaryTree *T,int position,char NEW);//修改树的结点
void DeleteTree(BinaryTree *T);//删除树
void PrintTree(BinaryTree *T,int layer);//按照树的形状打印树
int BiTreeDepth(BinaryTree *T);//求树的高度
int BiTreeDepth_recursive(BinaryTree *T);//递归求树的高度
int LeafNumber(BinaryTree *T);//求叶子的数目
int LeafNumber_recursive(BinaryTree *T);//递归求叶子的数目
void PreOrderTraverse(TreeNode *T,void (*visit)());//前序遍历
void PreOrderTraverse_recursive(TreeNode *T,void (*visit)());//递归求前序遍历
void InOrderTraverse(TreeNode *T,void (*visit)());//中序遍历
void InOrderTraverse_recursive(TreeNode *T,void (*visit)());//递归求中序遍历
void PostOrderTraverse(TreeNode *T,void (*visit)());//后序遍历
void PostOrderTraverse_recursive(TreeNode *T,void (*visit)());//递归求后序遍历
void LevelOrderTraverse(TreeNode *T,void (*visit)());//层次遍历

void display(int e);
void menu(void);
TreeNode *Traverse(TreeNode *Node);

char definition[maxsize];
int i=0;
int main()
{
    BinaryTree *T=NULL;
    int op=0;
    do
    {
        system("cls");
        menu();
        op=0;
        printf("          Please input your option[0-12]:");
        scanf("%d",&op);
        switch(op)
        {
            case 0:
                break;
            case 1:
            {
                if(T)
                {
                    printf("该二叉树已经存在,是否确认覆盖重新创建？1:是;2:否：");
                    int ok=0;
                    scanf("%d",&ok);
                    if(ok==0)
                    {
                        system("pause");
                        break;
                    }
                    else//free掉二叉树各个节点
                    {
                        BinaryTree *stack[maxsize],*p;
                        int top=-1;
                        stack[++top]=T;
                        while(top>-1)
                        {
                            p=stack[top--];
                            if(p->right)stack[++top]=p->right;
                            if(p->left)stack[++top]=p->left;
                            free(p);
                        }
                        T=NULL;
                    }
                }
                printf("请在一行内输入各个结点代号大写字母值，空结点用空格代替，请勿输入其他字符，树将以前序遍历方式建立\n");
                //char definition[maxsize];
                memset(definition,maxsize,'\0');
                i=0;
                getchar();
                gets(definition);//printf("\n%s\n",definition);
                //scanf("%s",definition);
                //CreateBiTree(&T,definition);
                CreateBiTree(&T);
                printf("恭喜创建成功！\n");
                system("pause");
                break;
            }
            case 2:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                int position=0;
                char NEW;
                printf("请按照树从左至右、从上到下的编号顺序，输入你要修改值的结点编号：");
                scanf("%d",&position);
                getchar();
                printf("\n请此处的新值[单个字母]：");
                scanf("%c",&NEW);
                int ok=EditTreeNode(T,position,NEW);
                if(ok==FALSE)printf("你输入的位置信息有误！\n");
                else printf("修改成功！\n");
                system("pause");
                break;
            }
            case 3:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                printf("该树的深度是：%d\n",BiTreeDepth(T));
                system("pause");
                break;
            }
            case 4:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                printf("该二叉树叶子数为：%d\n",LeafNumber(T));
                system("pause");
                break;
            }
            case 5:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                PreOrderTraverse(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 6:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                InOrderTraverse(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 7:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                PostOrderTraverse(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 8:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                LevelOrderTraverse(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 9:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                DeleteTree(T);
                T=NULL;
                printf("删除成功！\n");
                system("pause");
                break;
            }
            case 10:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                printf("提示：此处的二叉树是横向输出，树的每一行对应着这里的相应列：\n");
                PrintTree(T,0);
                system("pause");
                break;
            }
            case 11:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                printf("该树的深度是：%d\n",BiTreeDepth_recursive(T));
                system("pause");
                break;
            }
            case 12:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                printf("该二叉树叶子数为：%d\n",LeafNumber_recursive(T));
                system("pause");
                break;
            }
            case 13:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                PreOrderTraverse_recursive(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 14:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                InOrderTraverse_recursive(T,display);
                printf("\n");
                system("pause");
                break;
            }
            case 15:
            {
                if(!T)
                {
                    printf("该二叉树不存在！\n");
                    system("pause");
                    break;
                }
                PostOrderTraverse_recursive(T,display);
                printf("\n");
                system("pause");
                break;
            }
            default :
                printf("wrong input.\n");
                system("pause");
                break;
        }
    }while(op);
    return 0;
}


void CreateBiTree(BinaryTree **T)
{
    if(definition[i]==' ')*T=NULL;
    else
    {
        *T=(BinaryTree *)malloc(sizeof(BinaryTree));
        (*T)->visit=0;
        (*T)->data=definition[i++];
        CreateBiTree(&((*T)->left));
        i++;
        CreateBiTree(&((*T)->right));
    }
}
int EditTreeNode(BinaryTree *T,int position,char NEW)//修改树的结点
{
    BinaryTree *quene[maxsize],**p;
    int front=0,back=0;
    quene[back++]=T;
    int count=0;
    while(front<back)
    {
        p=&quene[front++];
        ++count;
        if(count==position)break;
        if((*p)->left)quene[back++]=(*p)->left;
        if((*p)->right)quene[back++]=(*p)->right;
    }
    if(count<position)return FALSE;
    (*p)->data=NEW;
    return TRUE;
}
void DeleteTree(BinaryTree *T)//删除树
{
    if(T)
    {
        BinaryTree *p=NULL;
        p=T;
        DeleteTree(T->left);
        DeleteTree(T->right);
        free(p);
        p=NULL;
    }
}
void PrintTree(BinaryTree *T,int layer)//按照树的形状打印树
{
     int i;
     if(T==NULL)
         return;
     PrintTree(T->right,layer+1);
     for(i=0;i<layer;i++)
         printf("  ");
     printf("%c\n",T->data);
     PrintTree(T->left,layer+1);
}
int BiTreeDepth(BinaryTree *T)//求树的高度
{
    BinaryTree *stack[maxsize],*p=T;
    int tag[maxsize];
    int top=-1;
    int count=0;
    while(p || top>-1)
    {
        while(p)
        {
            stack[++top]=p;
            tag[top]=0;
            p=p->left;
        }
        if(tag[top]==1)
        {
            count=count>(top+1)?count:(top+1);
            --top;
            p=NULL;
        }
        else
        {
            p=stack[top];
            tag[top]=1;
            p=p->right;
        }
    }
    return count;
}
int BiTreeDepth_recursive(BinaryTree *T)//递归求树的高度
{
    if(T==NULL)return 0;
    else
    {
        int h_left=0,h_right=0;
        if(T->left==NULL && T->right==NULL)return 1;
        h_left=BiTreeDepth_recursive(T->left);
        h_right=BiTreeDepth_recursive(T->right);
        return h_left>h_right?(h_left+1):(h_right+1);
    }
}
int LeafNumber(BinaryTree *T)//求叶子的数目
{
    BinaryTree *stack[maxsize],*p;
    int top=-1;
    int count=0;
    if(T)
    {
        stack[++top]=T;
        while(top>-1)
        {
            p=stack[top--];
            if(p->right)stack[++top]=p->right;
            if(p->left)stack[++top]=p->left;
            if(p->left==NULL && p->right==NULL)++count;
        }
        return count;
    }

}
int LeafNumber_recursive(BinaryTree *T)//递归求叶子的数目
{
    if(T==NULL)return 0;
    else
    {
        int left=0,right=0;
        if(T->left==NULL && T->right==NULL)return 1;
        if(T->left)
        left=LeafNumber_recursive(T->left);
        if(T->right)
        right=LeafNumber_recursive(T->right);
        return left+right;
    }
}
void PreOrderTraverse(BinaryTree *T,void (*visit)())//前序遍历
{
    BinaryTree *stack[maxsize],*p;
    int top=-1;
    if(T)
    {
        stack[++top]=T;
        while(top>-1)
        {
            p=stack[top--];
            visit(p->data);
            if(p->right)stack[++top]=p->right;
            if(p->left)stack[++top]=p->left;
        }
    }
}
void PreOrderTraverse_recursive(BinaryTree *T,void (*visit)())//递归求前序遍历
{
    if(T)
    {
        visit(T->data);
        PreOrderTraverse_recursive(T->left,display);
        PreOrderTraverse_recursive(T->right,display);
    }
}
void InOrderTraverse(BinaryTree *T,void (*visit)())//中序遍历
{
    BinaryTree *stack[maxsize],*p;
    int top=-1;
    while(top>-1 || T!=NULL)
    {
        while(T)
        {
            stack[++top]=T;
            T=T->left;
        }
        if(top>-1)
        {
            p=stack[top--];
            visit(p->data);
            T=p->right;
        }
    }
}
void InOrderTraverse_recursive(BinaryTree *T,void (*visit)())//递归求中序遍历
{
    if(T)
    {
        InOrderTraverse_recursive(T->left,display);
        visit(T->data);
        InOrderTraverse_recursive(T->right,display);
    }
}
void PostOrderTraverse(BinaryTree *T,void (*visit)())//后序遍历
{
    BinaryTree *stack[maxsize],*p=NULL;
    int top=-1;
    if(T)stack[++top]=T;
    while(top>-1)
    {
        p=stack[top--];
        if(p->visit)visit(p->data);
        else
        {
            p->visit=1;
            stack[++top]=p;
            if(p->right)
            {
                p->right->visit=0;
                stack[++top]=p->right;
            }
            if(p->left)
            {
                p->left->visit=0;
                stack[++top]=p->left;
            }
        }
    }

}
void PostOrderTraverse_recursive(BinaryTree *T,void (*visit)())//递归求后序遍历
{
    if(T)
    {
        PostOrderTraverse_recursive(T->left,display);
        PostOrderTraverse_recursive(T->right,display);
        visit(T->data);
    }
}
void LevelOrderTraverse(BinaryTree *T,void (*visit)())//层次遍历
{
    BinaryTree *quene[maxsize],*p;
    int front=0,back=0;
    quene[back++]=T;
    while(front<back)
    {
        p=quene[front++];
        visit(p->data);
        if(p->left)quene[back++]=p->left;
        if(p->right)quene[back++]=p->right;
    }
}



void menu(void)
{
    printf("\n\n");
    printf("      Menu for Binary Tree On Sequence Structure \n");
    printf("------------------------------------------------------------------\n");
    printf("    	  1.  创建二叉树              9. 删除二叉树\n");
    printf("    	  2.  修改二叉树             10. 显示二叉树\n");
    printf("    	  3.  非递归求树深度         11. 递归求树深度\n");
    printf("    	  4.  非递归求树叶子数       12. 递归求树叶子数 \n");
    printf("    	  5.  非递归前序遍历         13. 递归前序遍历\n");
    printf("    	  6.  非递归中序遍历         14. 递归中序遍历\n");
    printf("    	  7.  非递归后序遍历         15. 递归后序遍历\n");
    printf("    	  8.  层次遍历二叉树          0.退出(Exit)\n");
    printf("------------------------------------------------------------------\n");
}
void display(int e)
{
    printf("%c ",e);
}


celte
关注
专栏目录
二叉树基本操作
青耕_的博客
02-17 1646
二叉树的先序，中序，后序遍历的递归与非递归，二叉排序树的建立，添加，删除，满二叉树，完全二叉树的判断
二叉树的基本操作
最新发布
MT_125的博客
01-13 2359
二叉树遍历、统计节点个数、查找对应节点
二叉树的基本操作（共21个）
CXR_XC的博客
11-04 9850
简单介绍二叉树，并给出二叉树的21种基本操作
二叉树的基本应用，基本操作都有
06-08
二叉树的基本应用，基本操作都有二叉树的基本应用，基本操作都有二叉树的基本应用，基本操作都有二叉树的基本应用，基本操作都有二叉树的基本应用，基本操作都有二叉树的基本应用，基本操作都有
二叉树各种操作
01-03
二叉树的各种操作。排序，宽度高度等等。写的不好
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树各种操作c语言代码
06-04
二叉树的各种遍历以及插入删除操作。 printf("-----------------------程序说明---------------------------\n"); printf("１．本程序涉及二叉树的所有操作。\n"); printf("２．创建操作为先序输入，输入０代表空。\...
二叉树各种操作的总结
quinn的专栏
07-26 5710
求二叉树中的节点个数 求二叉树中叶子节点的个数 求二叉树的深度 求二叉树第K层的节点个数 递归遍历前序中序后序 非递归遍历前序中序后序层序 1 前序遍历 2 中序遍历 3 后序遍历 4 层序遍历 将二叉查找树变为有序的双向链表 判断两棵二叉树是否结构相同 判断二叉树是不是平衡二叉树 判断二叉树是否是搜索二叉树 求二叉树中两个节点的最低公共祖先节点 求二叉树中节点的最大距离 由前序遍历序列和中序遍历序列重建二叉树
二叉树的各种应用与操作。
qq_43352073的博客
03-31 389
1.输入前序 求后序中序。 2. 输入二叉树的先序遍历序列和中序遍历序列，输出该二叉树的后序遍历序列 3. 已知一棵二叉树的中序遍历和后序遍历，求二叉树的先序遍历 4. 已知一个按先序输入的字符序列，如abd,eg,cf,(其中,表示空结点)。请建立二叉树并求二叉树的层次遍历序列。 5. 一棵二叉树的前序遍历和中序遍历，求二叉树的后序遍历和层序遍历。 6. 已知二叉树的一个按先序遍历输入的字符序列...
二叉树所有基本操作
weixin_55858644的博客
01-06 6671
最全的二叉树基本操作
二叉树的各种操作(递归和非递归遍历,树深度,结点个数等等)
zxzxin的博客~
04-03 3787
目录 建立二叉树 递归前序和非递归前序 递归中序和非递归中序 递归后续和非递归后续(包括双栈法和设置pre结点) 层次遍历 寻找树中有没有值为x的结点 统计树中结点的个数 计算树的高度 判断两颗树是不是相等 前序中序，中序后续建立二叉树 树的子结构 二叉树镜像 二叉树建立 可以根据二叉树根节点和左右子结点的下标关系递归建立二叉树，层次输入二叉树结点，递归建立，代码如下： ...
二叉树的建立和基本操作
热门推荐
Roope的专栏
11-14 1万+
树形结构要多利用递归来求解，递归的关键就是想清楚所有的基准情形，然后扩展到一般情况，写代码的时候最好把基准情况放在前面，把一般情况放在后面！ 定义二叉树结构体： [cpp] view plaincopy typedef struct BinaryTreeNode   {       TelemType data;       stru
二叉树操作实现与算法分析
- 文档详细列出了不同类型的二叉树操作，包括创建、遍历、统计属性、修改和删除节点等。 - **创建二叉树**：介绍了如何构建二叉树，可能涉及到从用户输入或特定数据结构初始化二叉树。 - **遍历**： - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值