二叉通用树C语言实现---双亲孩子法

coding__madman coding__madman 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1k累计阅读 1k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
原创 最新推荐文章于 2026-04-06 11:47:05 发布 1k 阅读 AI 写同款· GEO 优化 ›
【数据结构】哈夫曼树及哈夫曼编码实现（C语言） 目录1. 哈夫曼树1.1 基本概念1.2 构造哈夫曼树1.3 哈夫曼树的类型定义1.4 哈夫曼树创建的算法实现2. 哈夫曼编码实现2.1 哈夫曼编码2.2 完整代码2.3 运行结果 1. 哈夫曼树 1.1 基本概念 路径：指从根结点到该结点的分支序列。 路径长度：指根结点到该结点所经过的分支数目。 结点的带权路径长度：从树根到某一结点的路径长度与该结点的权的乘积。 树的带权路径长度(WPL)：树中从根到所有叶子结点的各个带权路径长度之和。 哈夫曼树是由 n 个带权叶子结点构成的所有二叉树中带权路径长度最短的 阅读详情

还是国嵌之前数据结构和算法视频里面唐老师的代码，最近刷二叉树的相关题目，整好拿来用用，先贴源代码，顺便复习一下，老师的代码真的很棒！后边借助老师之前的链表以及栈的实现，非递归实现二叉树的前序遍历、中序遍历、后续遍历、以及层次遍历-全部用栈实现。

目标实现如下二叉树，并且打印结果，

/举例
/************************************
              A
            /    \
           B     C
         /   \    /  \
        D   E F   G
      /   \  / 
     H   I J
*************************************/

先贴代码：

BTree.c

#include <stdio.h>
#include <malloc.h>
#include "BTree.h"

// 定义二叉树根结点结构体
typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;                // 记录二叉树结点个数
    BTreeNode* root;          // 二叉树结点指针结构体，指向树结点根节点
};

// 创建二叉树
BTree* BTree_Create() // O(1)
{
    // 定义二叉树结点结构体变量，并申请内存
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}

// 销毁二叉树
void BTree_Destroy(BTree* tree) // O(1)
{
    free(tree);       // 释放内存
}

// 清空二叉树
void BTree_Clear(BTree* tree) // O(1)
{

    TBTree* btree = (TBTree*)tree;

    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

// 在二叉树指定位置pos插入结点node
// pos：定位的方向，二进制：0表示左，1表示右
// count:定位次数，移动指针次数
// flag：插入方向 BT_LEFT or BT_RIGHT
int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag) // O(n) 
{

    TBTree* btree = (TBTree*)tree;    
    // 入口参数合法性检查
    int ret = (btree != NULL) && (node != NULL) && ((flag == BT_LEFT) || (flag == BT_RIGHT));
    int bit = 0;

    if( ret )
    {

        BTreeNode* parent = NULL;
    	// 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;
        // 初始化插入结点的左右指针地址，默认为NULL
        node->left = NULL;
        node->right = NULL;
        // 开始定位  定位次数不为零，插入的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            // 临时变量更新当前指针，保存插入结点位置的双亲指针
            parent = current;
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;        // 将当前结点指针指向左边子结点指针
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;       // 将当前结点指针指向右边子结点指针
            }
            // 定位次数减1
            count--;
        }
        // 定位完成后，如果该位置节点已经存在，判断待插入结点的插入位置flag表示插入该节点后，原位置的节点在该节点的左边还是右边
        if( flag == BT_LEFT )
        {
            node->left = current;           // 将带插入结点的左指针指向当前结点
        }
        else if( flag == BT_RIGHT )
        {
            node->right = current;          // 将待插入结点的右指针指向当前结点
        }
        
        // 当前结点指针不为空，即不是根结点
        if( parent != NULL )
        {

            if( bit == BT_LEFT )
            {
                parent->left = node;         // 将插入结点位置的双亲指针的左指针指向待插入结点
            }
            else if( bit == BT_RIGHT )
            {
                parent->right = node;        // 将插入结点位置的双亲指针的右指针指向待插入结点
            }
        }
        // 插入的是首结点，即根结点
        else
        {
            btree->root = node;
        }
        // 二叉树结点个数加1
        btree->count++;
    }
    
    return ret;
}

// 显示递归函数
static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;
    // 合法性检查OK
    if( (node != NULL) && (pFunc != NULL) )
    {
    	// 打印格式符
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        // 打印内容
        pFunc(node);
        
        printf("\n");
        // 存在左子树结点或存在右子树结点
        if( (node->left != NULL) || (node->right != NULL) )
        {
 
            recursive_display(node->left, pFunc, format + gap, gap, div);      // 调用递归函数打印左子树结点
            recursive_display(node->right, pFunc, format + gap, gap, div);     // 调用递归函数打印右子树结点
        }
    }
    // 根结点为空
    else
    {    	  
    	  // 打印格式符
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}


// 显示二叉树
void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div) // O(n)
{
	  // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 合法性检查OK，调用显示递归函数
    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

// 求二叉树结点子树结点个数
static int recursive_count(BTreeNode* root) // O(n)
{
    int ret = 0;
    // 合法性检查ok
    if( root != NULL )
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);    // 调用递归函数计算个数
    }
    // 返回个数
    return ret;
}



int BTree_Count(BTree* tree)
{

    TBTree* btree = (TBTree*)tree;
    int ret = 0;    
    // 入口参数合法性检查ok，调用递归函数求二叉树高度
    if( btree != NULL )
    {
        ret = recursive_count(btree->root);
    }
    // 返回二叉树高度
    return ret;

}

// 删除指定位置的结点
BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;    

    if( btree != NULL )
    {
    	  // 定义二叉树左右指针结构体临时变量
        BTreeNode* parent = NULL;
    	  // 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;        
        // 开始定位  定位次数不为零，删除的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            
            // 临时变量更新当前指针，保存删除结点位置的双亲指针
            parent = current;            
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;         // 将删除结点位置的双亲指针的左指针指向待删除结点
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;        // 将删除结点位置的双亲指针的右指针指向待删除结点
            }
            // 定位次数减1             
            count--;
        }        
        // 当前结点指针不为空，即不是根结点
        if( parent != NULL )
        {
            // 左边
            if( bit == BT_LEFT )
            {
                parent->left = NULL;         // 将结点左子树位置指向空指针，即删除左结点
            }
            // 右边
            else if( bit == BT_RIGHT )
            {
                parent->right = NULL;        // 将结点右子树位置指向空指针，即删除右结点
            }
        }
        // 删除的是首结点，即根结点
        else
        {
            btree->root = NULL;              // 将根结点指向空指针，即删除所有结点
        }
        // 返回删除元素结点
        ret = current;
        // 更新二叉树结点个数，结点个数减去删除的结点个数
        btree->count = btree->count - recursive_count(ret);
    }
    
    return ret;
}

// 获取指定位置的结点
//如果获取的节点位置为空怎么办 
BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL; 
    int bit = 0;
    int i = 0;
    
    // 入口参数合法性检查ok
    if( btree != NULL )
    {
    	// 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;        
        // 开始定位  定位次数不为零，删除的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }
            //printf("the tree node is %d\n", i++);
            // 定位次数减1   
            count--;
        }
        
        ret = current;
   
    }
    
    return ret;
}

// 获取根结点
BTreeNode* BTree_Root(BTree* tree) // O(1)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL;
    // 入口参数合法性检查ok，返回根结点地址
    if( btree != NULL )
    {
        ret = btree->root;
    }
    
    return ret;
}

// 求二叉树高度递归函数
static int recursive_height(BTreeNode* root) // O(n)
{
    int ret = 0;
    if( root != NULL )
    {
        int lh = recursive_height(root->left);       // 求左子树高度
        int rh = recursive_height(root->right);      // 求右子树高度
        // 求左右子树高度最大值
        ret = ((lh > rh) ? lh : rh) + 1;
    }
    // 返回二叉树高度
    return ret;
}

// 获取二叉树高度
int BTree_Height(BTree* tree) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    int ret = 0;    

    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    // 返回二叉树高度
    return ret;
}

// 求二叉树度递归函数，最大度为2
static int recursive_degree(BTreeNode* root) // O(n)
{

    int ret = 0;    

    if( root != NULL )
    {
    	 // 左子树结点不为空，度加1
        if( root->left != NULL )
        {
            ret++;
        }        
    	 // 右子树结点不为空，度加1
        if( root->right != NULL )
        {
            ret++;
        }
        // 度为1，调用递归函数求其他结点度
        if( ret == 1 )
        {
            int ld = recursive_degree(root->left);       // 求左子树结点的度
            int rd = recursive_degree(root->right);      // 求右子树结点的度
            // 求左子树结点度的最大值
            if( ret < ld )
            {
                ret = ld;
            }            
            // 求右子树结点度的最大值
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }

    return ret;
}


// 获取二叉树度
int BTree_Degree(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;    

    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    // 返回二叉树的度
    return ret;
}

BTree.h

#ifndef __BTREE_H_
#define __BTREE_H_
 
#define BT_LEFT 0            //  左边
#define BT_RIGHT 1           //  右边


// 定义新数据类型，用于封装函数
typedef void BTree;
typedef unsigned long long BTPos;

// 定义二叉树左右指针结构体
typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
    BTreeNode* left;         // 二叉树左结点指针
    BTreeNode* right;        // 二叉树右结点指针
};

typedef void (BTree_Printf)(BTreeNode*);

 
void BTree_Destroy(BTree* tree);

BTree* BTree_Create();

void BTree_Clear(BTree* tree);

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Root(BTree* tree);

int BTree_Height(BTree* tree);

int BTree_Degree(BTree* tree);

int BTree_Count(BTree* tree);

 
#endif

测试demo :main.c

#include <stdio.h>
#include <stdlib.h>
#include "BTree.h"
 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
// 定义二叉树数据域结构体
struct Node
{
    BTreeNode header;
    char v;
};
// 定义打印内容函数
void printf_data(BTreeNode* node)
{
    if( node != NULL )
    {
        printf("%c", ((struct Node*)node)->v);
    }
}
 
int main(int argc, char *argv[])
{
	  // 创建二叉树
    BTree* tree = BTree_Create();
    // 定义要插入结点元素
    struct Node n1 = {{NULL, NULL}, 'A'};
    struct Node n2 = {{NULL, NULL}, 'B'};
    struct Node n3 = {{NULL, NULL}, 'C'};
    struct Node n4 = {{NULL, NULL}, 'D'};
    struct Node n5 = {{NULL, NULL}, 'E'};
    struct Node n6 = {{NULL, NULL}, 'F'};
	struct Node n7 = {{NULL, NULL}, 'G'};
	struct Node n8 = {{NULL, NULL}, 'H'};
	struct Node n9 = {{NULL, NULL}, 'I'};
	struct Node n10 = {{NULL, NULL}, 'J'};  
    // 插入结点元素
	// 在二叉树指定位置pos插入结点node
	// pos：定位的方向，二进制：0表示左，1表示右
	// count:定位次数，移动指针次数
	// flag：插入方向 BT_LEFT or BT_RIGHT
	
    BTree_Insert(tree, (BTreeNode*)&n1, 0x00, 0, 0);//A 根节点 
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);//B
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);//C
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);//D
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);//E
    BTree_Insert(tree, (BTreeNode*)&n6, 0x01, 2, 0);//F
    BTree_Insert(tree, (BTreeNode*)&n7, 0x03, 2, 0);//G
    BTree_Insert(tree, (BTreeNode*)&n8, 0x00, 3, 0);//H
    BTree_Insert(tree, (BTreeNode*)&n9, 0x04, 3, 0);//I
    BTree_Insert(tree, (BTreeNode*)&n10, 0x02, 3, 0);//J
    // 打印相应提示内容
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    if((struct Node*)BTree_Get(tree, 0x02, 2) != NULL)
    	printf("Position At (0x02, 2): %c\n", ((struct Node*)BTree_Get(tree, 0x02, 2))->v);
    printf("Full Tree: \n");
    // 显示二叉树
    BTree_Display(tree, printf_data, 4, '-');
    // 测试删除结点功能
    BTree_Delete(tree, 0x00, 1);   
    // 打印相应提示内容
    printf("After Delete B: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Full Tree: \n");    
    // 显示删除结点后的二叉树
    BTree_Display(tree, printf_data, 4, '-');
    
    // 测试清空二叉树功能
    BTree_Clear(tree);    
    // 打印相应提示内容
    printf("After Clear: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));    
    // 显示清空后的二叉树
    BTree_Display(tree, printf_data, 4, '-');
    // 销毁二叉树
    BTree_Destroy(tree);
    
	return 0;
}

部分测试运行结果：

/************************************
              A
            /    \
           B     C
         /   \    /  \
        D   E F   G
      /   \  / 
     H   I J
*************************************/

二叉树里面好多接口函数用到了递归，递归本质其实就是一个栈结构，用递归能实现的，用栈都可以实现。该代码精髓在节点插入和节点删除的地方。考虑的比较全面，多多仔细推敲代码能收获不少。

收录于
数据结构与算法

当前文章被收录于：

数据结构与算法
16 篇文章 0 人学习
订阅专栏 查看详情
标签
#二叉通用树 #递归 #C语言 #数据结构 #算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
哈夫曼树与哈夫曼编码——c语言详解 本文目录：哈夫曼编码c语言实现1. 前言2. 定义数据结构3. 构建哈夫曼树4. 构造哈夫曼编码5. 输出哈夫曼编码6. 测试程序7. 程序汇总 哈夫曼编码c语言实现 1. 前言 本学期数据结构课程使用的教材为清华大学出版社的《 数据结构（c语言版）》，由于书中采用了很多伪码，使得对c语言掌握不是很熟悉的同学有学习上的困难。所以二叉树章节中，我尝试编写出更适合新手的哈夫曼编码的c语言程序，一方面帮... 阅读详情

相关推荐

数据结构之树的孩子链表表示法

#include"tree.h" const int max = 100; typedef char TElemType; typedef struct CTNode { int child; struct CTNode *next; }*ChildPtr,CTNode; typedef struct { int parent; TElemType data; ...

summersunrain的博客 8920

孩子兄弟树详解（C语言版）

孩子兄弟树详解（C语言版）

qq_44075108的博客 5858

树的双亲表示法（C语言实现详解版）

前面讲了二叉树的顺序存储和链式存储，本节来学习如何存储具有普通树结构的数据。 图1 普通树存储结构 如图 1 所示，这是一棵普通的树，该如何存储呢？通常，存储具有普通树结构数据的方法有 3 种： 双亲表示法； 孩子表示法； 孩子兄弟表示法...

数据结构和算法教程（C语言版） 3472

最新C语言深入剖析班项目实战教程(国嵌 唐老师主讲)

C语言深入剖析班 国嵌 唐老师主讲 视频教程 教学视频 百度网盘下载 C语言深入剖析班 国嵌 唐老师主讲 视频教程 教学视频 百度网盘下载 C语言深入剖析班 国嵌 唐老师主讲 视频教程 教学视频 百度网盘下载 下载地址：百度网盘 ...

weixin_44982650的博客 662

树的孩子表示法（C语言）详解

前面学习了如何用双亲表示法存储普通树，本节再学习一种存储普通树的方法——孩子表示法。 孩子表示法存储普通树采用的是 "顺序表+链表" 的组合结构，其存储过程是：从树的根节点开始，使用顺序表依次存储树中各个节点，需要注意的是，与双亲表示法不同，孩子表示法会给各个节点配备一个链表，用于存储各节点的孩子节点位于顺序表中的位置。 如果节点没有孩子节点（叶子节点），则该节点的链表为空链表。 例如，使...

数据结构和算法教程（C语言版） 2556

ubuntu20.04下dsp-slam的运行配置

DSP-SLAM：具有深度形状先验的面向对象的 SLAM

baidu_38431960的博客 3158

[转]国嵌唐老师写给同学们的一封信

转自：http://www.enjoylinux.cn/bbs/read.php?tid=2698 同学们：       大家好！我写这封邮件给大家其实只是有感于同学们经常的，一直的，抱怨的，在群中讨论关于职业关于人生的一些问题。我觉得既然这些问题大家如此感兴趣，但似乎每次又没讨论出什么有用的结论，那我就来说说我个人的看法吧。   “做IT能做过30岁吗？” “是不是做IT最后的路肯定

CoCo的专栏 2179

从零到一：基于Rocky Linux 9的Kubernetes高可用集群部署实战

本文提供了一份基于Rocky Linux 9操作系统，从零开始部署Kubernetes高可用集群的完整实战指南。详细讲解了包括系统初始化、容器运行时配置、使用kubeadm工具进行集群初始化、节点加入以及Calico网络插件安装在内的核心步骤，并针对国内网络环境提供了镜像加速等优化方案，旨在帮助读者构建一个稳定可靠的生产级K8s环境。

weixin_29197835的博客 134

一道面试题的思考。。。

本文摘自国嵌聊天群聊记录： 国嵌唐老师(22134670) 21:04:16 下一个题是一个同学面试时遇见的，他被鄙视了，大家看看自己是否可以过关。题目如下： 在32位机器上，用你觉得最高效的方法实现 memcpy 函数。 void* memcpy(void* dest, void* src, unsigned int size); Success(60

yangluoning的专栏 1475

嵌入式下载故障排查：ST-LINK与GD32 Programmer典型问题解决

嵌入式固件烧录是MCU开发的关键环节，其本质依赖于调试器（如ST-LINK、GD-Link）与目标芯片间的协议通信、驱动加载及硬件接口协同。原理上，SWD/JTAG协议需在正确时序、电平与供电条件下完成设备枚举、ID读取与Flash编程；技术价值在于保障量产烧录稳定性与调试可重复性；典型应用场景涵盖STM32/GD32教学开发、工业控制板量产调试及Windows 11新系统适配。本文聚焦ST-LINK-V2在Keil MDK中的下载失败和GD32 All In One Programmer的DLL加载异常两

weixin_35006125的博客 153

计组实验4 控制冒险与分支预测

目录前言实验内容背景知识分支预测技术⭐阻塞周期计算方法不开启 BTB开启 BTBpart 1 矩阵乘法与优化未开启 BTB 的分析开启 BTB 的分析part 2 设计代码使 BTB 无效part 3 循环展开优化矩阵乘法未开启 BTB开启 BTB结束语结论 前言 上一篇博客：计组实验3 mips冒险之流水线冒险 摸了半个月了。。。咕咕咕 今天来写计组实验 4 这个实验非常简单，就是有点难。 这个实验比较容易算错，或者是被模拟器出人意料的结果搞的神神叨叨的，所以今天来记录并且详细分析该实验。 注：请务必阅

AKGWSB 's blog 5666

国嵌，够欠！---ARM在线教育误区

大家好，先自我介绍一下，我是国嵌学院的一个很普通的学员，因为应届生不好找工作，去培训机构培训又和上课时间冲突，所以选择了自主学习。在机缘巧合之下，购买了国嵌学院的嵌入式Linux开发课程，在此，踏上了一条不归路。 不归路之一：学无所用 我们学习，最终是想让自己的钱包鼓一点，出去玩的时候舒服一点，在单位自己的地位提高一点。因此，买了视频之后开始了我的学习生涯。从刚开始的环境搭建到裸机开发，一路走...

work_alone的博客 1万+

用deepseek对GPU服务器进行压力测试

利用 DeepSeek 模型对 GPU 服务器进行压力测试，核心思路是通过，验证 GPU 服务器在计算、显存、网络等维度的承载能力，同时观察稳定性与性能瓶颈。

weixin_42795092的博客 1608

#36_C数据结构树（待完善）

本文系统介绍了树结构在计算机科学中的核心概念与应用。大纲从树的基本定义和术语出发，详细阐述了二叉树的性质、存储结构和遍历算法（深度优先与广度优先）。重点分析了二叉搜索树、AVL树、红黑树等常见变体及其操作特性，并探讨了堆和哈夫曼树等特殊结构。在存储方面对比了顺序存储和链式存储的实现差异，最后列举了树结构在文件系统、数据库索引等领域的典型应用场景。全文采用严谨的数学表示和规范的代码风格，为理解树这一重要数据结构提供了全面而系统的技术参考。

qq_73850061的博客 319

【数据集处理】基于ERA5 气温/湿度数据计算湿球温度并判别湿热浪

【数据集处理】基于ERA5 气温/湿度数据计算湿球温度并判别湿热浪

WW、forever的博客 485

stop pin/ignore pin/exclude pin/float pin

stop pin、ignore pin、exclude pin、float pin的区别

m0_61544122的博客 7288

树的双亲表示法，孩子表示法以及孩子兄弟表示法

文章目录树的双亲表示法树的孩子表示法树的孩子兄弟表示法 顺序存储和链式存储，本节来学习如何存储具有普通树结构的数据。 树的双亲表示法 双亲表示法采用顺序表（也就是数组）存储普通树，其实现的核心思想是：顺序存储各个节点的同时，给各节点附加一个记录其父节点位置的变量。 注意，根节点没有父节点（父节点又称为双亲节点），因此根节点记录父节点位置的变量通常置为 -1。 /* * @Description: 树的双亲表示法 * @Version: V1.0 * @Autor: Carlos * @Date:

嵌入式与Linux那些事的博客 8926

[VCS]VCS dump fsdb的精细化控制

本文介绍了VCS FSDB波形dump的精细化控制方法。主要内容包括：1）基本dump方式；2）通过$fsdbDumpoff排除特定层次；3）使用$fsdbDumpvars选择性dump指定模块；4）运行时动态控制dump开关；5）通过文件管理排除列表（$fsdbDumpoffFile或自定义读取）；6）层次控制策略（剪除整棵树或仅当前层）。这些方法可有效控制波形文件大小，提高仿真效率。

元直的博客 1033

数据结构c语言——树的三种存储结构（双亲表示法、孩子表示法、兄弟表示法）

在大量的应用中，人们曾使用多种形式的存储结构来表示树。这里,我们介绍3种常用的链表结构。 1.双亲表示法： 假设以一组连续空间存储树的结点，同时在每个结点中附设一个指示器指示其双亲结点在链表中的位置,其形式说明如下: 例如，图6.13展示一棵树及其双亲表示的存储结构。 这种存储结构利用了每个结点(除根以外)只有惟一的双亲的性质。PARENT(T,x)操作可以在常量时间内实现。反复调用PARENT操作，直到遇见无双亲的结点时，便找到了树的根,这就是ROOT(x)操作的执行过程。但是，在这种表示法中,求结点

hey，欢迎浏览我的博客，希望能给你提供帮助。 1万+

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0， 兼容Win7/Win10/WinXP，解压就可用。

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员，提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列，各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性，请参见数据手册。有关 ARM Cortex™-M4F 内核的信息，请参见《Cortex™-M4F 技术参考手册》。

树的存储结构（双亲表示法，孩子双亲表示法，孩子兄弟表示法）——C语言描述

树的存储结构（双亲表示法，孩子双亲表示法，孩子兄弟表示法）——C语言描述

m0_59469991的博客 1463

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox（带书签），MATLAB统计学习工具

树双亲表示法，孩子表示代码实现

//双亲表示法 #include <stdio.h> #include <malloc.h> #define MAX 12 //巧妙使用顺序和链式存储可以实现树的存储结构 //双亲表示法是使用顺序存储来实现的 typedef struct pNode{ char data; int parent; //存放双亲在数组中的下标 } pNode; //使用顺序...

chp_woAIdan的博客 1145

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等，可在创建的窗口进行控制

树的双亲表示法，孩子表示法，孩子兄弟表示法（C语言）

树的双亲表示法：使用顺序表 /*#include<stdio.h> #include<stdlib.h> //节点结构 typedef struct Node { char data; int parent; }Node...

882

树的孩子兄弟表示法完整代码实现

#include<stdio.h> #include<malloc.h> typedef char ElemType; #define MaxSize 15 typedef struct CSNode { ElemType data; struct CSNode* firstchild, * nextsibling; }CSNode, * CSTree; typedef struct { CSNode* data[MaxSize]; //存放栈中的数据元素 int top;

Miss Z的博客 8631

树结构的双亲孩子表示法

以如下形式的树结构为例： 该树的深度为3， 其双亲孩子表示法如下： 表中第一列为结点编号，第二列为结点数据，第三列为该节点的双亲编号（根节点双亲为-1），后面的单链表表示了该节点所有的孩子，从左至右依次进行遍历。   代码实现如下： #define MAX_TREE_SIZE 100 typedef char ElemType; // 孩子结点 typedef struc...

满城丶琉璃月 3398

数据结构:树的5种存储方案详解（C语言完整实现）

数据结构中的树结构常用来存储逻辑关系为 "一对多" 的数据。这篇文章篇幅较长，我会给大家详细介绍两种树结构的各个存储方法，并提供完整的 C 语言实现源码。

zdoeo的博客 1765
上一篇： 单链表系列
下一篇： 二叉树通用树层次遍历、前序遍历、中序遍历、后序遍历栈结构非递归实现
点赞 0
评论 0
书签 书签 3
coding__madman
coding__madman
博客等级 码龄11年 188粉丝 76原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值