算法与数据结构-二叉树的基本操作C语言实现

最新推荐文章于 2024-04-25 17:36:21 发布
最新推荐文章于 2024-04-25 17:36:21 发布
阅读量2.3k 收藏 25
点赞数 3
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_35692628/article/details/77432198
版权

序言

二叉树这部分当时学习C语言的时候就没有特别重视，现在遇到这类题就比较头疼，所以需要重新复习一下。


二叉树的基本操作包括哪些

  • 二叉树的建立

    • 逐个结点输入
    • 广义表方式输入

  • 广义表方式输出二叉树

  • 二叉树的销毁

  • 求二叉树的深度

  • 二叉树的遍历

  • 统计二叉树的结点数

  • 统计二叉树的叶子结点数

  • 交换左右子树

  • 复制二叉树

  • 查找某一结点

  • 删除二叉树的某一结点


1. 二叉树的定义
typedef ElemType char;     //自定义数据域类型

struct BinaryTree
{
    ElemType data;                //数据域
    struct BinaryTree *lchild;    //左子树
    struct BinaryTree *rchild;    //右子树
};

typedef struct BinaryTree TreeNode;      //给结构体struct BinaryTree取个别名叫TreeNode
typedef struct BinaryTree * BiTree;      //给结构体指针struct BinaryTree *取个别名叫BiTree


//初始化
void IniBTree(BiTree BT)
{
    BT = NULL;
    return;
}


2. 二叉树的建立
  • 方法1：逐个结点输入
/* 先序创建二叉树:根结点 -> 左子树 -> 右子树 */
void CreateBTree(BiTree BT)
{
    char ch;
    ch = getchar();        //头文件<stdio.h>，相当于scanf("%c", &ch)
    if (ch == ' ')
        BT = NULL;
    else
    {
        if(! (BT = (BiTree)malloc(sizeof(TreeNode))))
            exit(1);
        BT -> data = ch;         //生成根节点
        BT -> lchild = NULL;   //构造左子树
        BT -> rchild = NULL;   //构造右子树
        CreateBiTree(BT -> lchild);
        CreateBiTree(BT -> rchild);
    }
}
  • 方法2：利用广义表建立二叉树
    • 即根据广义表 A（B（C，D），E（，F（G）））的输入，建立二叉树
int StackMaxSize = 3;

void CreateBTreeWithGenList(BiTree BT, char *string)
{
    BiTree TempNode;
    Bitree s[StackMaxSize];    //定义数组为存储各结点的指针的栈
    int top = -1;     //栈顶指针，初始值为-1
    int branchValue;  //分支值，作为处理结点的标志，1表示处理左子树，2表示处理右子树
    int i = 0;        //数组计数元素

    //原二叉树初始化
    BT = NULL;

    //开始读入广义表字符串
    while (string[i])
    {
        switch(string[i])
        {
            case ' ': break;

            case '(':
            {
                if (top == StackMaxSize - 1)
                {
                    printf("栈空间太小，需要增大栈空间!\n");
                    exit(1);
                }
                top++;
                s[top] = TempNode;
                k = 1;                //切换到左子树
                break;              
            }

            case ')':
            {
                if (top == -1)
                {
                    printf("二叉树广义表字符串错误\n");
                    exit(1);
                }
                top--;
            }

            case ',': k = 2; break;   //切换到右子树 

            default:                  //默认情况下，即读取到字母字符，对应赋值。
            {
                TempNode = (BiTree)malloc(sizeof(TreeNode));
                TempNode -> data = string[i];                    //临时结点赋值
                TempNode -> lchild = TempNode -> rchild = NULL;
                if (BT == NULL)
                    BT = TempNode;           //根节点赋值
                else
                {
                    if (k == 1)
                        s[top] -> lchild = TempNode;
                    else
                        s[top] -> rchild = TempNode;
                }
            }
        } //switch结束
    i++;
    }  //while结束
}


3. 广义表方式输出二叉树
void PrintBTreeWithGenList(BiTree BT)
{
    if (BT)
    {
        printf("%c", BT -> data);

        if (BT -> lchild || BT -> rchild)
        {
            printf("(");
            PrintBTreeWithGenList(BT -> lchild);
            if (BT -> rchild)
            {
                printf(",");
                PrintBTreeWithGenList(BT -> rchild);
            }
            printf(")");
        }
    }
}


4. 二叉树的销毁
void DestroyBTree(BiTree BT)
{
    if (BT)
    {
        DestroyBTree(BT -> lchild);
        DestroyBTree(BT -> rchild);
        free(BT);
        BT == NULL;
    }
}


5. 检查二叉树是否为空
int BTreeEmpty(BiTree BT)
{
    if (BT == NULL)
        return 1;
    else
        return 0;
}


6. 求二叉树的深度
//递归方式计算二叉树的深度,每一层的深度都能够得到比较

int BTreeDepth(BiTree BT)
{
    if (BT == NULL)
        return 0;
    else
    {
        int depth1 = BTreeDepth(BT -> lchild);     //计算左子树的深度
        int depth2 = BTreeDepth(BT -> rchild);     //计算右子树的深度
        if (depth1 > depth2)
            return depth1 + 1;
        else
            return depth2 + 1;
    }
}


//或递归方式求二叉树的深度
int BTreeDepth(BiTree BT)
{
    if (BT == NULL)
        return 0;
    else
    {
        int ldepth = BTreeDepth(BT -> lchild);
        int rdepth = BTreeDepth(BT -> rchild);
    }
    return (ldepth > rdepth) ? (ldepth + 1) : (rdepth + 1);
}


7. 二叉树的遍历
/* 前序遍历：根节点 -> 左子树 -> 右子树 */
void PreOrderTraverse(const BiTree BT)
{
    if (!BT)
        return;
    //遍历
    printf("%c ", BT -> data);        //根节点
    PreOrderTraverse(BT -> lchild);
    PreOrderTraverse(BT -> rchild);
}


/* 中序遍历：左子树 -> 根节点 -> 右子树 */
void InOrderTraverse(const BiTree BT)
{
    if (!BT)
        return;
    //遍历
    InOrderTraverse(BT -> lchild);
    printf("%c ", BT -> data);        //根节点
    InOrderTraverse(BT -> rchild);
}


/* 后序遍历：左子树 -> 右子树 -> 根节点 */
void PostOrderTraverse(const BiTree BT)
{
    if (!BT)
        return;
    //遍历
    PostOrderTraverse(BT -> lchild);
    PostOrderTraverse(BT -> rchild);
    printf("%c ", BT -> data);        //根节点
}


/* 层序遍历：逐层从左到右 */
void LevelOrderTraverse(BiTree BT)
{
    BiTree temp;
    BiTree queue[QueueMaxSize];      //定义队列所使用的数组，元素类型为指向结点的指针类型
    int front = 0;
    int rear = 0;
    if (BT != NULL)                  //根结点入队
    {
        queue[rear] = BT;
        rear = (rear + 1) % QueueMaxSize;
    }
    while (front != rear)
    {
        temp = queue[front];
        front = (front + 1) % QueueMaxSize;
        printf("%c ", temp -> data);
        if (temp -> lchild != NULL)     //输出结点存在左子树
        {
            queue[rear] = temp -> lchild;
            rear = (rear + 1) % QueueMaxSize;
        }
        if (temp -> rchild != NULL)
        {
            queue[rear] = temp -> rchild;
            rear = (rear + 1) % QueueMaxSize;
        }
    }
}
//1. 层序遍历需要使用一个队列，开始把整个树的根结点入队，然后每从队列中删除一个结点并输出该结点时，都把它的非空的左右孩子入队，当队列为空时算法结束。
//2. 算法中，队列的最大长度不会超过二叉树中相邻的两层的最大结点数，所以提前在程序开始处定义最大队列长度QueueMaxSize大于队列的最大长度，就无需考虑队列溢出的问题了


8. 统计二叉树的结点数
/* 二叉树的结点数 = 左子树 + 右子树 + 1 */
int BTreeNodeCount(BiTree BT)
{
    if (BT == NULL)
        return 0;
    else
        return BTreeNodeCount(BT -> lchild) + BTreeNodeCount(BT -> rchild) + 1;
}


9. 统计二叉树的叶子结点数
/* 叶子结点：没有左右子树的结点 */
int BTreeLeafCount(BiTree BT)
{
    if (BT == NULL)
        return 0;
    if (BT -> lchild == NULL && BT -> rchild == NULL)
        return 1;
    //递归实现
    return BTreeLeafCount(BT -> lchild) + BTreeLeafCount(BT -> rchlid);
}


10. 统计二叉树度为1的结点
/* 统计二叉树的度为1的结点个数 */
//度：一个结点的子结点的个数
int Degree1Count(BiTree BT)
{
    if(!BT) 
        return 0;
    if ((!BT -> lchild && BT -> rchild) || (BT -> lchild && !BT -> rchild))
        return 1;
    else
        return Degree1Count(BT -> lchild) + Degree1Count(BT -> rchild);
}


11. 交换左右子树
/* 相当于对称翻转，递归实现 */
void ExchangeChildTree(BiTree BT)
{
    if (BT)
    {
        BiTree Temp = NULL;
        if (BT -> lchild || BT -> rchild)
        {
            ExchangeChildTree(BT -> lchild);
            ExchangeChildTree(BT -> rchild);
            Temp = BT -> lchild;
            BT -> lchild = BT -> rchild;
            BT -> rchild = Temp;
        }
    }
}


12. 复制二叉树
/* 递归实现 */
BiTree CopyBTree(BiTree BT)
{
    BiTree P, lchild, rchild;
    if (BT == NULL)
        return;
    lchild = CopyBTree(BT -> lchild);
    rchild = CopyBTree(BT -> rchild);
    P = (BiTree)malloc(sizeof(struct BinaryTree));
    P -> data = BT -> data;
    P -> lchild = lchild;
    P -> rchild = rchild;
    return P;
}


13. 查找某一结点
/* 查找某一结点：查找成功返回结点位置，失败返回NULL */

BiTree* FindBTree(BiTree BT, ElemType x)
{
    if (BT == NULL)
        return NULL;
    else                       //递归查找
    {
        if (x == BT -> data)
            return BT;
        else
        {
            ElemType* p;
            if (p = FindBTree(BT -> lchild, x))
                return p;
            if (p = FindBTree(BT -> rchild, x))
                return p;
            return NULL;
        }
    }
}


14. 删除二叉树的某一结点
  • 说明：二叉树删除结点有三种情况
    • [1] 该结点没有子结点：直接删除，并修改其父结点
    • [2] 该结点只有一个子结点：将该结点的子结点直接提升至该结点处，并修改相应的指针
    • [3] 若该z结点有两个子结点：找到z结点的中序后继结点y，并用y的右子树替换y结点，y结点替换z结点，z的左子树置为y的左子树。如下图所示



//此时的二叉树结构体定义修改为

typedef ElemType char;     //自定义数据域类型

struct BinaryTree
{
    ElemType data;                //数据域
    struct BinaryTree *prev;      //前驱结点，该指针的目的是为了方便找到父结点
    struct BinaryTree *lchild;    //左子树
    struct BinaryTree *rchild;    //右子树
};

typedef struct BinaryTree *BiTree;


//删除某一结点方式：先找到后删除
int DeleteBTreeNode(BiTree BT, ElemType x)
{
    //查找到该元素所在的结点位置，返回结点指针！
    BiTree temp = FindBTree(BT, x);
    if (temp == NULL)
        return 0;
    //1. 没有子结点
    if (temp -> lchild == NULL && temp -> rchild == NULL)
    {
        if (temp -> prev -> lchild == temp)      //如果是父结点的左子树
            temp -> prev -> lchild = NULL;
        else
            temp -> prev -> rchild = NULL;
        free(temp);
    }
    //2. 只有左子树
    if (temp -> rchild == NULL)
    {
        if (temp -> prev -> lchild == temp)     //如果是父结点的左子树
            temp -> prev -> lchild = temp -> lchild;
        else
            temp -> prev -> rchild = temp -> lchild;
        free (temp);
    }
    //3. 只有右子树
    if (temp -> lchild == NULL)
    {
        if (temp -> prev -> lchild == temp)      //如果是父结点的左子树
            temp -> prev -> lchild = temp -> rchild;
        else
            temp -> prev -> rchild = temp -> rchild;
        free (temp);
    }
    //4. 既有左子树又有右子树
    else
    {
        BiTree y = temp -> rchild;    //寻找中序后继结点y，即temp结点右子树的最左子树
        while (y -> lchild != NULL)
            y = y -> lchild;
        if (y == temp -> rchild)      //y是要删结点的右子树
        {
            //判断要删结点是其父结点的左子树还是右子树
            if (temp -> prev -> lchild == temp)     //左子树
            {
                temp -> prev -> lchild = y;
                y -> lchild = temp -> lchild;
                temp -> lchild -> prev = y;
            }
            else
            {
                temp -> prev -> rchild = y;
                y -> lchild = temp -> lchild;
                temp -> lchild -> prev = y;
            }
        }
        else
        {
            y -> prev -> lchild = y -> rchild;      //注意y的右子树可能不存在
            //同上。判断要删除结点是其父结点的左子树还是右子树
            if (temp -> prev -> lchild == temp)     //左子树
            {
                temp -> prev -> lchild = y;
                y -> lchild = temp -> lchild;
                y -> rchild = temp -> rchild;
                temp -> lchild -> prev = y;
                temp -> rchild -> prev = y;
            }
            else
            {
                temp -> prev -> rchild = y;
                y -> lchild = temp -> lchild;
                y -> rchild = temp -> rchild;
                temp -> lchild -> prev = y;
                temp -> rchild -> prev = y;
            }
        }
        free (temp);
    }
    return 1;
}

//注：为避免冗长，可将上述判断左右子树及结点替换的部分单独写一个函数实现。



Acknowledgements:
http://blog.csdn.net/sysu_arui/article/details/7865876
http://blog.csdn.net/wtfmonking/article/details/17038077（推荐）
http://blog.csdn.net/lub0807/article/details/37969059
http://blog.csdn.net/nzh1234/article/details/31076401
http://blog.csdn.net/heart_love/article/details/50943089

2017.08.20

shuaixio
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构锐格实验三--实验四：二叉树的常见操作
nefu_Luxembourg的博客
05-10 1130
7080 題目內容: 输入森林对应的二叉树的先序遍历序列，建立一棵二叉树，该二叉树就是森林的孩子兄弟表示法，输出森林的叶子结点个数。 二叉树结点类型为char,特殊字符为@。 例如：森林如下所示 image.png 该森林对应的二叉树的扩展形式如下图所示，将该二叉树看成是森林的孩子兄弟表示法。对空指针域采用@扩展。 image.png 输入二叉树的先序遍历序列：ABD@F@@@CE@@@ 输出森林的叶子结点个数：3 输入输出说明: 输入： ABD@@E@R@@CF@@GI@@@ 输出： 5 在这里插入代码片
实验三 二叉树基本操作的实现
陈的博客
12-06 1849
实验三 二叉树基本操作的实现 实验目的 掌握二叉树的存储实现 掌握二叉树的遍历思想 .掌握二叉树的基本操作的程序实现 实验内容 1.编写函数，输入字符序列，建立二叉树的二叉链表。 2.编写函数，实现二叉树的先序、中序、后序递归遍历操作。 3.编写函数，求二叉树的结点个数。 4.编写函数，求二叉树的叶子个数。 5.编写一个主函数，在主函数中设计一个简单的菜单，分别调用上述函数。 #include<stdio.h> #include<stdlib.h> #include<
算法与数据结构实战实验——树型数据结构及其应用（使用java）
Xuanf_q的博客
07-23 546
实验目的——通过实验达到： ⑴ 理解和掌握树及二叉树的基本概念； ⑵ 理解和掌握二叉树的顺序存储结构、链式存储结构； ⑶ 理解和掌握采用二叉链式存储结构下二叉树的各种遍历操作的思想及其应用； ⑷ 加深对堆栈、队列的概念及其典型操作思想的理解； ⑸ 掌握典型二叉树操作算法的算法分析。 题目：二叉树的建立、遍历及其应用 设树结点的元素类型为char，实现以下二叉树的各种基本操作的程序： ① 建立不少于10个结点的二叉树T； ②用后序遍历方式输出树T的结点； ③用层次遍历方式输出树T的结点； ④输出树.
二叉树详解(含各种基本操作 附代码）
m0_52949684的博客
11-16 787
本文含二叉树一下功能： 二叉树节点结构 创捷二叉树 查找二叉树 删除二叉树 前序遍历 中序遍历 后序遍历 层次遍历 复制二叉树 求深度 求节点数 求叶子节点 判断二叉树是否为空 代码如下： #include<stdio.h> #include<stdlib.h> typedef char ElemType; #define MAXSIZE 10 // 二叉树节点结构 typedef struct TreeNode{ ElemType data; //数据 struct Tr
二叉树基本操作
xinxin的博客
04-25 581
在构造函数的初始化列表中，将节点的值 `val` 初始化为参数 `x`，并将左右子节点的指针 `left` 和 `right` 初始化为 `nullptr`，表示初始时没有左右子节点。}`：如果当前节点不是叶子节点，则递归地统计左子树和右子树中度为0的节点个数，并返回它们的和。- `int count_Node_0(TreeNode* T) { ... }`：这是一个名为 `count_Node_0` 的函数，接受一个指向二叉树根节点的指针 `T`，返回度为0的节点个数。
实验 2：树形数据结构的实现与应用
Carefree_State的博客
05-19 639
C语言二叉树实验
数据结构之树和二叉树算法实现（C语言）
Jooey_Zhong
10-26 5381
待我学有所成，结发与蕊可好。@夏瑾墨 开发环境为Dev-C++ 5.11 编译器：MinGW GCC 6.1.0 64-bit 一、算法程序组建目录结构如下： 第一部分：头文件 1. c1.h 2. c3-3.h 3. c6-1.h 4. c6-2.h 5. c6-3.h 6. c6-4.h 7. c6-5.h 8. c6-7.h 第二部分：主程序入口文
数据结构实验-二叉树基本操作-C语言实现
风华正茂百花洲
04-27 851
#include <iostream> #include <stdlib.h> using namespace std; typedef struct node { char sh; struct node *lchild, *rchild; }TreeNode, *pTreeNode; //这里注意，必须要使用&，不然后面求二叉树深度时有误 void Cre...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
【数据结构与算法】二叉树的实现C语言代码
03-12
在IT领域，数据结构与算法是编程的基础，而二叉树作为其中的一种核心概念，有着广泛的应用。本主题聚焦于“二叉树的实现C语言代码”，旨在通过具体实例帮助理解二叉树的相关操作。 首先，我们要理解二叉树的基本...
算法与数据结构-c语言-二叉树与树.ppt
09-30
互联网文档
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
此PDF教材可能涵盖这些基本概念，并通过实例代码展示C语言中如何实现这些数据结构和算法。学习者不仅可以了解理论知识，还能动手实践，提升编程能力。通过学习，读者应能理解各种数据结构的特点和适用场景，掌握常见...
算法与数据结构-C语言版
06-14
在C语言这个强大的编程工具下，我们可以更直观地理解和实现各种算法与数据结构。 一、算法 1. **基础算法**：包括排序（冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等）和搜索（线性搜索、二分查找...
二叉树简单实现与基本操作（C语言）（西工大数据结构）
Lucky Home
03-19 865
二叉树简单实现与基本操作（C语言）二叉树基本操作二叉树定义二叉树遍历输出先序输出中序输出后序输出输出叶子结点建立二叉链表方式存储的二叉树先序遍历建立二叉树求树的深度求树的深度(后序遍历）求树的深度（先序遍历）总结 今天自学下二叉树，简单实现一些基本操作，因为这一块内容很多而且比较难，所以可能会有所纰漏，望大佬多多指点。 二叉树 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单
二叉树的建立与基本操作
weixin_38199770的博客
01-08 2776
编写程序实现二叉树的如下操作： 1) 建立二叉链表 2) 二叉树的先序、中序、后序遍历 3) 求解二叉树的叶子结点个 4) 将二叉树中所有结点的左、右子树相互交换 输入： 　　扩展二叉树先序序列：ab#d##ce###。其中#代表空指针。 输出：        二叉树的凹入表示 　　二叉树的先序序列、中序序列、后序序列 　　二叉树叶子结点个数 　　左、右子树相互交换后
八．二叉树各种操作的C语言实现 树的一些基本的操作，包括，树的建立，树的深度，
晴天的专栏
08-15 1298
首先是定义的树的数据结构： typedef struct BiTNode { TElemType data; struct BiTNode *lchild; struct BiTNode *rchild; }BiTNode,BiTree,*BiTree_1; 下面是树的一些基本的操作，包括，树的建立，树的深度，树的各种遍历的递归和非递归实现; Status InitBiTree(B
【数据结构】二叉树的基本操作大全，学会二叉树基本操作这一篇就够了：二叉树前序、中序、后序、层次遍历；求二叉树总结点个数，叶子结点个数，二叉树第k层的结点个数；求二叉树的高度；在二叉树中查找值为x的结点
2301_76606232的博客
01-03 1912
【数据结构】二叉树的基本操作大全，学会二叉树基本操作这一篇就够了：二叉树前序、中序、后序、层次遍历；求二叉树总结点个数，叶子结点个数，二叉树第k层的结点个数；求二叉树的高度；在二叉树中查找值为x的结点
【数据结构6】二叉树的基本操作
程序员好冰的博客
05-30 1190
二叉树的一些基本操作，比如：先序创建、按满二叉树创建、三种递归遍历、三种非递归遍历、层次遍历、先序和中序线索化并遍历、求树的叶子节点数以及树的深度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值