二叉树和相关操作--c语言

已于 2023-08-17 18:27:56 修改
阅读量114 收藏
点赞数 1
分类专栏： 数据结构 文章标签： c语言 数据结构 开发语言
于 2023-07-31 20:06:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EGALong/article/details/132027788
版权
本文详细介绍了二叉树的链式存储结构，包括先序、中序、后序和层次遍历的递归实现，以及线索二叉树的中序、先序和后序线索化方法，用于高效遍历。同时，还探讨了二叉排序树的查找和插入操作。所有代码均提供了清晰的实现。
摘要由CSDN通过智能技术生成

目录

•二叉树的链式存储结构

typedef struct BiTNode{
    ElemType data;  //数据域
    struct BiTNode *lchild;    //左子树结点指针
    struct BiTNode *rchild;    //右子树结点指针
    //添加根结点指针，构成二叉树的三叉链表
    //struct BiTNode *parent;
}BiTNode,*BiTree;

 
 

•二叉树的遍历

1.先序遍历

//先序遍历（前缀表达式）
void PreOrder(BiTree T){
    if(T != NULL){
        visit(T);  //访问根节点
        PreOrder(T->lchild);  //访问左节点
        PreOrder(T->rchild);  //访问右节点
    }
}

 

2.中序遍历

//中序遍历（中缀表达式）
void InOrder(BiTree T){
    if(T != NULL){
        PreOrder(T->lchild);  //访问左节点
        visit(T);  //访问根节点
        PreOrder(T->rchild);  //访问右节点
    }
}

 

3.中序遍历

//后序遍历（后缀表达式）
void PostOrder(BiTree T){
    if(T != NULL){
        PreOrder(T->lchild);  //访问左节点
        PreOrder(T->rchild);  //访问右节点
        visit(T);  //访问根节点
    }
}

利用递归工作栈进行的三种顺序遍历每个结点都访问且仅访问一次，时间复杂度都是 O ( n ) O(n) O(n)；
在最坏情况下，二叉树有n个结点且深度为n，此时空间复杂度为 O ( n ) O(n) O(n)。

 

4.层次遍历

这里用到的队列相关操作见 《队列的相关操作》

//层次遍历
void LevelOrder(BiTree T){
    LinkQueue Q;  //创建一个辅助队列
    INitQueue(Q);  //初始化队列
    BiTree p;  //存储需要访问的出队结点
    EnQueue(Q,T); //根节点入队
    while(!ISEmpty(Q)){
        //队列非空时，进行循环
        DeQueue(Q,p);  //队头结点出队
        visit(p);  //访问出队结点
        if(p->lchild != NULL){
            EnQueue(Q,p->lchild);  //出队结点的左孩子入队
        }
        if(p->rchild != NULL){
            EnQueue(Q,p->rchild);  //出队结点的右孩子入队
        }
    }
}

 

5.代码汇总

#include <stdio.h>
#include <stdbool.h>

#define ElemType int

//二叉树的链式存储结点
typedef struct BiTNode{
    ElemType data;  //数据域
    struct BiTNode *lchild;    //左子树结点指针
    struct BiTNode *rchild;    //右子树结点指针
    //添加根结点指针，构成二叉树的三叉链表
    //struct BiTNode *parent;
}BiTNode,*BiTree;


//-------------------------------------------------------------------
//一个任意的访问函数
void visit(BiTree T) {
    /*
     * 编写相应的访问函数
     */
}
//-------------------------------------------------------------------


//-------------------------------------------------------------------
//先序遍历（前缀表达式）
void PreOrder(BiTree T){
    if(T != NULL){
        visit(T);  //访问根节点
        PreOrder(T->lchild);  //访问左节点
        PreOrder(T->rchild);  //访问右节点
    }
}

//中序遍历（中缀表达式）
void InOrder(BiTree T){
    if(T != NULL){
        PreOrder(T->lchild);  //访问左节点
        visit(T);  //访问根节点
        PreOrder(T->rchild);  //访问右节点
    }
}

//后序遍历（后缀表达式）
void PostOrder(BiTree T){
    if(T != NULL){
        PreOrder(T->lchild);  //访问左节点
        PreOrder(T->rchild);  //访问右节点
        visit(T);  //访问根节点
    }
}

//层次遍历
void LevelOrder(BiTree T){
    LinkQueue Q;  //创建一个辅助队列
    INitQueue(Q);  //初始化队列
    BiTree p;  //存储需要访问的出队结点
    EnQueue(Q,T); //根节点入队
    while(!ISEmpty(Q)){
        //队列非空时，进行循环
        DeQueue(Q,p);  //队头结点出队
        visit(p);  //访问出队结点
        if(p->lchild != NULL){
            EnQueue(Q,p->lchild);  //出队结点的左孩子入队
        }
        if(p->rchild != NULL){
            EnQueue(Q,p->rchild);  //出队结点的右孩子入队
        }
    }
}
//-------------------------------------------------------------------

 
 

•线索二叉树

//线索二叉树结点
typedef struct ThreadNode{
    ElemType data;  //数据域
    struct ThreadNode *lchild;    //左子树结点指针
    struct ThreadNode *rchild;    //右子树结点指针
    bool ltag;  //线索判断左右指针是线索还是孩子结点
    bool rtag;  //true为线索，false为孩子结点
}ThreadNode,*ThreadTree;

 

1.中序线索化

通过中序遍历进行线索化

//通过中序遍历进行的中序线索化
void InThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){
        //对左孩子结点进行线索化
        InThread(p->lchild,pre);
        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点
        //对右孩子结点进行线索化
        InThread(p->rchild,pre);
    }
}

void CreateInThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        InThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}

 

中序线索二叉树的遍历

//求中序序列下的第一个结点
ThreadNode *FirestNode(ThreadNode *p){
    while(p->ltag == false){
        //当前结点有左孩子，则往前继续找
        p = p->lchild;
    }
    return p;
}

//求当前结点的中序后继
ThreadNode *NextNode(ThreadNode *p){
    if(p->rtag == false){
        //当前结点有右子树，则返回右子树的第一个结点
        return FirestNode(p->rchild);
    }else{
        //当前结点右子树为空，直接返回后继结果
        return p->rchild;
    }
}

由上面两个函数，可以构成不含头结点的中序线索二叉树的中序遍历算法

//中序线索二叉树的中序遍历
void ThreadInOrder(ThreadTree T){
    for(ThreadNode *p = FirestNode(T); p != NULL; p = NextNode(p)){
        //创建结点p初始化为T树的第一个结点，逐次访问其后继
        visit(p);
    }
}

 

2.先序线索化

大致操作与中序相同，修改各个部分线索化顺序即可

//后序线索二叉树
//通过先序遍历进行的先序线索化
void PreThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){

        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点

        //对左孩子结点进行线索化
        if(p->ltag == false){
            //左子树不是其前驱线索时，才进行线索化
            PreThread(p->lchild,pre);
        }

        //对右孩子结点进行线索化
        PreThread(p->rchild,pre);
    }
}
void CreatePreThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        PreThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}

 

3.后序线索化

//后序线索二叉树
//通过后序遍历进行的后序线索化
void PostThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){

        //对左孩子结点进行线索化
        PostThread(p->lchild,pre);

        //对右孩子结点进行线索化
        PostThread(p->rchild,pre);

        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点
    }
}
void CreatePostThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        PostThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}

 

4.代码汇总

#include <stdio.h>
#include <stdbool.h>

#define ElemType int

//线索二叉树结点
typedef struct ThreadNode{
    ElemType data;  //数据域
    struct ThreadNode *lchild;    //左子树结点指针
    struct ThreadNode *rchild;    //右子树结点指针
    bool ltag;  //线索判断左右指针是线索还是孩子结点
    bool rtag;  //true为线索，false为孩子结点
}ThreadNode,*ThreadTree;


//-------------------------------------------------------------------
//中序线索二叉树
//通过中序遍历进行的中序线索化
void InThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){
        //对左孩子结点进行线索化
        InThread(p->lchild,pre);
        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点
        //对右孩子结点进行线索化
        InThread(p->rchild,pre);
    }
}
void CreateInThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        InThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}

//求中序序列下的第一个结点
ThreadNode *FirestNode(ThreadNode *p){
    while(p->ltag == false){
        //当前结点有左孩子，则往前继续找
        p = p->lchild;
    }
    return p;
}
//求当前结点的中序后继
ThreadNode *NextNode(ThreadNode *p){
    if(p->rtag == false){
        //当前结点有右子树，则返回右子树的第一个结点
        return FirestNode(p->rchild);
    }else{
        //当前结点右子树为空，直接返回后继结果
        return p->rchild;
    }
}
//中序线索二叉树的中序遍历
void ThreadInOrder(ThreadTree T){
    for(ThreadNode *p = FirestNode(T); p != NULL; p = NextNode(p)){
        //创建结点p初始化为T树的第一个结点，逐次访问其后继
        visit(p);
    }
}
//-------------------------------------------------------------------


//-------------------------------------------------------------------
//先序线索二叉树
//通过先序遍历进行的先序线索化
void PreThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){

        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点

        //对左孩子结点进行线索化
        if(p->ltag == false){
            //左子树不是其前驱线索时，才进行线索化
            PreThread(p->lchild,pre);
        }

        //对右孩子结点进行线索化
        PreThread(p->rchild,pre);
    }
}
void CreatePreThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        PreThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}
//-------------------------------------------------------------------


//-------------------------------------------------------------------
//后序线索二叉树
//通过后序遍历进行的后序线索化
void PostThread(ThreadNode *p, ThreadNode *pre){
    //结点非空才能进行线索化
    if(p != NULL){

        //对左孩子结点进行线索化
        PostThread(p->lchild,pre);

        //对右孩子结点进行线索化
        PostThread(p->rchild,pre);

        //对根结点进行线索化
        if(p->lchild == NULL){
            //左孩子为空，则建立前驱线索
            p->lchild = pre;
            p->ltag = true;
        }
        if(pre != NULL && pre->rchild == NULL){
            //前驱结点非空，且前驱无右孩子，则建立前驱右孩子的后继线索
            pre->rchild = p;
            pre->rtag = true;
        }
        pre = p;  //更新前驱结点为当前结点
    }
}
void CreatePostThread(ThreadTree T){
    ThreadNode *pre = NULL;  //指向被访问结点的前驱结点
    if(T != NULL){
        //非空二叉树才能进行线索化
        PostThread(T,pre);  //中序线索化
        //处理最后一个结点
        if(pre->rchild == NULL){
            pre->rtag = 1;
        }
    }
}
//-------------------------------------------------------------------

 
 

•二叉排序树

 

1.查找

有递归与非递归两种

//非递归查找
BSTNode *BST_Search(BSTree T, ElemType key) {
    while (T != NULL && key != T->data) {
        //当树结点T非空且T值不是key值时进行循环判定
        if (key < T->data) {
            T = T->lchild;  //key值比T值小，继续向T的左子树寻找
        }else{
            T = T->rchild;  //key值比T值大，继续向T的右子树寻找
        }
    }
    return T;  //返回符合key的结点T，没有找到则T为空
}

//递归查找
BSTNode *BST_Search1(BSTree T, ElemType key){
    if(T == NULL){
        return NULL;  //查找失败
    }
    if(key == T->data){
        return T;  //查找成功
    }
    if (key < T->data) {
        return BST_Search1(T->lchild, key);  //key值比T值小，继续向T的左子树寻找
    }
    if(key > T->data){
        return BST_Search1(T->rchild, key);  //key值比T值大，继续向T的右子树寻找
    }
}

 

2.插入

和查找的方法差不多，也是查找找到正确位置以后增加一个插入操作
循环进行插入操作，就可以构建一个二叉排序树

//非递归插入
bool BST_Insert(BSTree T, ElemType key) {
    while (T != NULL && key != T->data) {
        //当树结点T非空，则继续移动
        if (key < T->data) {
            T = T->lchild;  //key值比T值小，继续向T的左子树移动
        } else {
            T = T->rchild;  //key值比T值大，继续向T的右子树移动
        }
    }
    if(key == T->data){
        return false;  //存在关键字相同的结点，插入失败
    }else{
        //找到正确位置的空结点T以后，进行插入操作
        T = (BSTree) malloc(sizeof(BSTNode));
        T->data = key;
        T->lchild = NULL;
        T->rchild = NULL;
        return true;
    }
}

//递归插入
bool BST_Insert1(BSTree T, ElemType key) {
    if (T == NULL) {
        T = (BSTree) malloc(sizeof(BSTNode));
        T->data = key;
        T->lchild = NULL;
        T->rchild = NULL;
        return true;
    }
    if (key == T->data) {
        return false;  //存在关键字相同的结点，插入失败
    }
    if (key < T->data) {
        return BST_Insert1(T->lchild, key);  //key值比T值小，继续向T的左子树插入
    }
    if (key > T->data) {
        return BST_Insert1(T->rchild, key);  //key值比T值大，继续向T的右子树插入
    }
}

 

3.代码汇总

#include <stdio.h>
#include <stdbool.h>
#include <malloc.h>

#define ElemType int

//二叉排序树的链式存储结点
typedef struct BSTNode {
    ElemType data;  //数据域
    struct BSTNode *lchild, *rchild;    //左右子树结点指针
} BSTNode, *BSTree;

//------------------------------------------------------------------
//非递归查找
BSTNode *BST_Search(BSTree T, ElemType key) {
    while (T != NULL && key != T->data) {
        //当树结点T非空且T值不是key值时进行循环判定
        if (key < T->data) {
            T = T->lchild;  //key值比T值小，继续向T的左子树寻找
        } else {
            T = T->rchild;  //key值比T值大，继续向T的右子树寻找
        }
    }
    return T;  //返回符合key的结点T，没有找到则T为空
}

//递归查找
BSTNode *BST_Search1(BSTree T, ElemType key) {
    if (T == NULL) {
        return NULL;  //查找失败
    }
    if (key == T->data) {
        return T;  //查找成功
    }
    if (key < T->data) {
        return BST_Search1(T->lchild, key);  //key值比T值小，继续向T的左子树寻找
    }
    if (key > T->data) {
        return BST_Search1(T->rchild, key);  //key值比T值大，继续向T的右子树寻找
    }
}
//------------------------------------------------------------------


//------------------------------------------------------------------
//非递归插入
bool BST_Insert(BSTree T, ElemType key) {
    while (T != NULL && key != T->data) {
        //当树结点T非空，则继续移动
        if (key < T->data) {
            T = T->lchild;  //key值比T值小，继续向T的左子树移动
        } else {
            T = T->rchild;  //key值比T值大，继续向T的右子树移动
        }
    }
    if(key == T->data){
        return false;  //存在关键字相同的结点，插入失败
    }else{
        //找到正确位置的空结点T以后，进行插入操作
        T = (BSTree) malloc(sizeof(BSTNode));
        T->data = key;
        T->lchild = NULL;
        T->rchild = NULL;
        return true;
    }
}
//递归插入
bool BST_Insert1(BSTree T, ElemType key) {
    if (T == NULL) {
        T = (BSTree) malloc(sizeof(BSTNode));
        T->data = key;
        T->lchild = NULL;
        T->rchild = NULL;
        return true;
    }
    if (key == T->data) {
        return false;  //存在关键字相同的结点，插入失败
    }
    if (key < T->data) {
        return BST_Insert1(T->lchild, key);  //key值比T值小，继续向T的左子树插入
    }
    if (key > T->data) {
        return BST_Insert1(T->rchild, key);  //key值比T值大，继续向T的右子树插入
    }
}
//------------------------------------------------------------------
EGALong
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树的基本操作-C语言
Sock的博客
12-29 585
二叉树的基本操作 在了解了二叉树的概念之后, 大家会发现二叉树的其实是一个递归的思维, 因此它的创建, 遍历以及销毁等操作可以用递归来实现 具体实现 定义一个二叉树 //定义一个二叉链表 typedef struct Node { char data; struct Node* lchild; struct Node* rchild; }BitNode, *BiTree; 递归创建一个二...
C语言二叉树的基本操作（超全）
qq_51553982的博客
05-25 4万+
二叉树作为数据结构其实是一个挺有意思的结构，可以有多种应用 我们直接来看一下二叉树的代码： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> #define maxsize 100 //二叉树的基本操作：建立，前序，中序，后序，层次，求叶子数，求层数,求结点树 //二叉树的数据结构 //创建数据域和左右指针域 typedef struct Tree { c
二叉树相关操作---纯代码实现详解
热门推荐
weixin_64067830的博客
07-06 6万+
二叉树相关操作---纯代码实现详解，快来看看吧！
二叉树的基本操作-C语言实现-数据结构作业
kim的博客
05-15 7523
目录 (1)二叉树的创建； (2)二叉树的先序、中序和后序遍历输出； (3)输出二叉树的叶子节点和度为2的节点的数量； (4)输出二叉树的深度； (5)将二叉树所有节点的左右子树互换(左子树变右子树，右子树变左子树)； (6)参考书上，二叉树按层次输出(一行输出一层)； (7)删除二叉树(释放二叉树所有节点空间)； 完整代码 运行结果展示 编写一个带菜单的实验演示系统（参考前面实验的菜单系统）。要求演示以下功能（界面、函数及相关数据结构等根据需要自行设计和定义）： (1)二叉树的创.
二叉树的基本操作 ---------C语言实现
qq_52781326的博客
10-29 146
二叉树的基本操作 本篇主要包括二叉树的创建，前序遍历，中序遍历，后序遍历等基本操作 。。。更基础的知识就不在这里赘述了。 二叉树的创建 由于是通过链式结构存储的，先定义二叉树的链式结构体。 typedef struct BiTNode { int data; struct BiTNode* lchild; struct BiTNode* rchild; } BITNODE,*BITree **struct BiTNode =BITNODE; 意思是用BITNODE 代替struct B
二叉树的操作及运用程序c语言,二叉树基本操作-C语言实现
weixin_39949889的博客
05-19 172
#include typedef struct BiTNode{int data;struct BiTNode *lchild, *rchild;} BiTNode, *BiTree;void CreatBiTree(BiTree &T){int e;scanf("%d", &e);if(e==0){T = NULL;}else{T = (BiTNode *)malloc(size...
二叉树的ADT----数据结构（C语言）
qq_55072730的博客
01-21 2104
C语言数据结构--二叉树的基本操作。功能：树的先序非递归遍历，中序递归遍历，后续三叉树遍历，树的初始化，树的分解，树的判空，替换左右子树，查找第k个访问的结点，查找结点，求叶子树，求结点数等
[ 数据结构-C语言 ] 二叉树--初阶 大总结~~
CSDN博客
04-14 1万+
今天要和大家一起步入一个新的数据结构--二叉树。在学习了解二叉树之前我们先来了解什么是树。 目录 1.树的概念及其结构 1.1树的概念 1.2树的相关概念(重点*) 1.3树的表示 2.二叉树概念及结构 2.1概念 2.2特殊的二叉树 2.3二叉树的性质（重要*） 2.4练习题 2.5 二叉树的存储结构 1. 顺序存储 2.链式存储 3.二叉树的顺序结构及实现 3.1 二叉树的顺序结构 3.2堆概念及其结构 3.2.1堆的实现 3.2.2堆的时间复杂...
二叉树先序遍历算法--C语言
lei2014lei的博客
12-13 7614
第一次在CSDN上写博客，今天开启自己的编程之路。以前总觉得上课嘛，把老师讲的东西学会，考试能过就好了。但是后来发现，自己被这种想法坑惨了。知识点当时是学会了，但是随着考试的结束，学到的知识也一并还给了老师！！！这对于找工作的我来说，打击相当之大。现在下定决心要好好学习，重拾忘掉的知识。先从二叉树开始吧！ 今天看了二叉树的先序遍历，便尝试着写了二叉树的先序遍历算法（非递归）。以下代码为已经编译运行...
求c语言二叉树的叶子结点,C语言实现二叉树的基本操作---创建、遍历、求深度、求叶子结点...
weixin_32380307的博客
05-22 582
// 二叉树.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include#includetypedefintElemType;//数据类型typedefint Status;//返回值类型//定义二叉树结构typedef struct BiTNode{ElemTypedata;//数据域struct BiTNode *lChild;//左子树域struct ...
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
c语言基础-c语言编程基础之树操作-反转二叉树.zip
03-17
总结来说，理解和掌握C语言中的树操作，特别是反转二叉树，对于提升C语言编程能力至关重要。通过实践这些概念，不仅可以加深对数据结构的理解，还能为后续学习高级算法打下坚实基础。在学习过程中，不断练习和编写...
二叉树-基于Objective-C的完全二叉树实现的优先队列.zip
04-26
5. **遍历操作**：完全二叉树支持前序、中序和后序遍历，这些遍历方法在处理优先队列时可能很有用，比如打印队列中的元素。 6. **优化**：为了提高性能，可以考虑使用惰性删除、路径压缩等技术，尤其是在处理大量...
二叉树的使用报告--数据结构（C语言）.doc
05-13
总的来说，二叉树的使用报告展示了如何在C语言中实现和操作二叉树，包括遍历、变形和删除等操作，这些都是数据结构和算法学习中的重要组成部分。理解并掌握这些概念和技术对于进一步深入学习计算机科学至关重要。
20240821让飞凌的OK3588-C的核心板在Linux R4下挂载1TB的exFAT格式的TF卡
最新发布
南岭笑笑生之家
08-21 736
Linux mkfs、fsck等文件系统相关工具移植：dosfstools(FAT32)、exfatprogs(exFAT)、e2fsprogs(ext2、ext3、ext4)20240821让飞凌的OK3588-C的核心板在Linux R4下挂载1TB的exFAT格式的TF卡。对于TF卡/SD卡联盟【移动存储，包括U盘和移动硬盘】，微软贡献了文件系统的专利。1、三大主流操作系统（Linux、Mac、Windows）都支持exfat格式。对于更大容量的介质，微软导入了exFAT。
C控制语句：分支和跳转（1）
lly_b的博客
08-21 547
本篇摘要：if语句if....else语句getchar()和putchar()在 C 语言中，if语句用于根据条件的真假来决定是否执行特定的代码块。if。
数据结构之并查集
我要学编程的博客
08-21 1182
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
【408数据结构】概述
weixin_46876169的博客
08-18 778
程序 = 数据结构 + 算法算法是求解问题的步骤。
森林与二叉树的转换 - 数据结构C语言实现
在C语言描述中，这些转换通常用于理解和操作树结构。森林转换成二叉树的规则如下：如果森林为空，则转换得到的二叉树也为空；若森林非空，二叉树的根节点为森林中第一棵树的根节点，左子树由第一棵树的子树森林转换...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值