C语言数据结构之树超全详解

最新推荐文章于 2024-07-05 18:34:12 发布
最新推荐文章于 2024-07-05 18:34:12 发布
阅读量5.9k 收藏 164
点赞数 28
文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45468845/article/details/105256564
版权

目录


因为时间原因里面还有一些代码没有完善，有时间我会补充上去。

基础知识

二叉树的一些基本概念

在这里插入图片描述
度：结点拥有的子树数称为该结点的度,结点B的结点为2
分支结点（非终端结点）： 度不为0的结点
叶子（终端结点）：度为0的结点
树的度：树内各结点的度的最大值，上图中D结点的度最大为3，所以这个树的度为3
孩子：结点的子树的根，该结点称为孩子的双亲
兄弟：同一个双亲的孩子之间互称兄弟
祖先：从根到该节点所经分支的所有结点
子孙：以某结点为根的子树中任一结点都是该结点的子孙
堂兄弟：双亲在同一层的结点互为堂兄弟
结点的层次：从跟开始定义，根为第一层，根的孩子为第二层
若某结点在第n层，其子树的根就在(n+1)层
树的深度（高度）：树中结点的最大层次
结点的深度，高度，和层次

  • 结点的层次从树根开始定义，根节点为第一层（有的教材定义为第0层），根节点的子节点为第二层
  • 结点的深度：从根节点开始自顶向下逐层累加到该结点
  • 结点的高度：从叶子结点开始自低向上逐层累加到该结点

路径和路径长度：

  • 树中两个结点之间的路径是由这两个结点之间所经历的结点序列构成的，
  • 而路径长度是路径上所经历的边的个数

森林：m(m>=0)棵互不相交的树的集合

树的性质

  1. 书中的结点数等于所有结点的度数加1
  2. 度为m的书中第i层上之多由m的(i-1)次方个结点
  3. 高度为h的m叉树至多有
  4. 具有n个结点的m叉树的最小高度wei

二叉树的一些基本性质

性质 1 ：在二叉树的第 i 层上至多有2i-1 个结点(i ≥ 1)。
性质 2 ：深度为 k 的二叉树上至多含 2k-1 个结点（k≥1）。
性质 3 ：对任何一棵二叉树，若它含有n0 个叶子结点、n2 个度为 2 的结点，则必存在关系式：n0 = n2+1。
两类特殊的二叉树：
满二叉树：指的是深度为k且含有2k-1个结点的二叉树。（左图）
完全二叉树：树中所含的 n 个结点和满二叉树中编号为 1 至 n 的结点一一对应。（右图）

在这里插入图片描述

操作部分

二叉树的存储结构

上面啰嗦了这么多，下面开始进入正题啦，下面介绍二叉树的几种存储结构

1.顺序存储结构

在这里插入图片描述

#define MAX_TREE_SIZE 100
typedef TElemType SqBiTREE[MAX_TREE_SIZE];
SqBiTree bt;

顺序存储结构仅适用于完全二叉树

2.链式存储结构

(1). 二叉链表
二叉树链式存储的结点结构
在这里插入图片描述

typedef struct BiTNode { // 结点结构
    TElemType      data;
    struct BiTNode  *lchild, *rchild;// 左右孩子指针
} BiTNode, *BiTree;

在这里插入图片描述
看一个简单的创建并遍历二叉树的程序：

# include <stdio.h>
# include <stdlib.h>
#define TElemType int

/*二叉树的结点结构*/
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

/*创建二叉树*/
BiTree CreateBiTree(){

	BiTree T;

	/*分配存储空间*/
	T = (BiTNode *)malloc(sizeof(BiTNode));
	T->lchild = (BiTNode *)malloc(sizeof(BiTNode));
	T->rchild = (BiTNode *)malloc(sizeof(BiTNode));
	T->lchild->lchild= (BiTNode*)malloc(sizeof(BiTNode));

	/*赋值*/
	T->data = 1;
	T->lchild->data = 2;
	T->rchild->data = 3;
	T->lchild->lchild->data = 4;

	/*让结点的指针域为空*/
	T->lchild->lchild->lchild = NULL;
	T->lchild->lchild->rchild = NULL;
	T->lchild->rchild = NULL;
	T->rchild->lchild = NULL;
	T->rchild->rchild = NULL;
	return T;
}	

int main(){
	/*创建二叉树*/
	BiTree Tree = CreateBiTree();
	printf("%d",Tree->lchild->lchild->data);
	return 0;
}

输出结果为：4
这个二叉树的结构如下：
在这里插入图片描述

但是实际应用中，不可能在创建的时候手动给二叉树赋值，一般都是动态加入的。
代码如下：

#include <stdio.h>
#include <stdlib.h>
#define OVERFLOW -2

typedef char TElemType;

/*二叉树的结点结构*/
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

/*创建二叉树*/
BiTree CreateBiTree(BiTree T){
	/*分配存储空间*/
	T = (BiTNode *)malloc(sizeof(BiTNode));

	char ch;
	scanf("%c",&ch);
	//如果输入为空，则二叉树是空树
	if(ch=='#'){
		T = NULL;
	}else{
		if(!T){
			printf("分配存储空间失败！");
			exit(OVERFLOW);
		}
		T->data = ch;//先输入根结点
		T->lchild = CreateBiTree(T->lchild);//递归生成左子树
		T->rchild = CreateBiTree(T->rchild);//递归生成右子树
	}
	return T;
}	


int main(){
	/*创建二叉树*/
	BiTree T;
	printf("请输入二叉树中的元素 # 表示空\n");
	BiTree Tree = CreateBiTree(T);
	return 0;
}

需要注意的是递归创建左右子树的时的代码：

T->lchild = CreateBiTree(T->lchild);//递归生成左子树
T->rchild = CreateBiTree(T->rchild);//递归生成右子树

输入：124##5##3##
二叉树就创建成功了，遍历二叉树会在后面介绍到
在这里插入图片描述
创建的二叉树为：
在这里插入图片描述

(2)．三叉链表
由二叉链表的结点结构可知，想要找到结点的双亲是比较困难的，为了找到结点的双亲，可以在结点结构中增加一个指向双亲的指针域。如下所示
在这里插入图片描述
由这种结点结构所构成的二叉树的存储结构分别称为三叉链表。
在这里插入图片描述

typedef struct TriTNode { // 结点结构
  TElemType       data;
  struct TriTNode  *lchild, *rchild;// 左右孩子指针
  struct TriTNode  *parent;  //双亲指针 
} TriTNode, *TriTree;

(3)．双亲链表
结点结构：
在这里插入图片描述

typedef struct BPTNode { // 结点结构
     TElemType  data;
     int  *parent;     // 指向双亲的指针
     char  LRTag;    // 左、右孩子标志域
} BPTNode
typedef struct BPTree{ // 树结构
     BPTNode nodes[MAX_TREE_SIZE];
     int  num_node;     // 结点数目
     int  root;                // 根结点的位置
} BPTree

(4).线索链表

使用二叉链表创建二叉树：

BiTree CreateBiTree(BiTNode *T)
{
 char c;
 scanf("%c",&c);
 if(c==' '){
  T=NULL;
 } else{
  T=(BiTNode *)malloc(sizeof(BiTNode));
  T->data=c;
  T->lchild=CreateBiTree(T->lchild);
  T->rchild=CreateBiTree(T->rchild);
 }
 return T;
}

3.线索二叉树

当以二叉链表作为存储结构时，无法直接得到在任一序列中结点的前驱和后继信息，这种信息只有在遍历的动态过程中才能得到。
如何保存这种在遍历过程中得到的信息呢？
可以做如下规定：
若结点有左子树，则其lchild域 指示其左孩子，否则令 lchild域 指示其前驱；
若结点有右孩子，则其rchild域 指示其右孩子，否则令 rchild域 指示其后继。
为避免混淆，在结点结构上增加两个标志域
在这里插入图片描述
LTag=

  • 0 lchild域指示结点的左孩子
  • 1 lchild域指示结点的前驱

RTag=

  • 0 rchild域指示结点的左孩子
  • 1 rchild域指示结点的前驱
    以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向结点前驱和后继的指针，叫做线索，加上线索的二叉树称之为线索二叉树
    线索化：对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化
    在线索树上进行遍历，只需要先找到 序列中的第一个结点，然后依次找结点后继直到其后继为空时即止。
    看一个中序线索链表

在这里插入图片描述
注意： a 才是根节点，根节点是模仿线性表的存储结构，在二叉树的线索链表上也添加一个头节点，并令其lchild 域的指针指向二叉树的根节点，其rchild 域的指针指向中序遍历时访问的最后一个结点，
并使中序遍历序列中第一个结点的lchild 域指针，和最后一个结点的rchild域指针均指向头节点。
好比为二叉树建立了一个双向线索链表，既可从第一个结点起顺后继进行遍历，也可以从最后一个结点起顺前驱进行遍历

前驱与后继

可以看到，树中所有叶子节点的右链是线索，右链域直接指示了结点的后继。

但是树中非终端结点的右链均为指针，怎么能得到后继的信息呢？

在中序线索链表中：
根据中序遍历的规律可知，结点的后继应该是遍历其右子树时访问的第一个结点，即右子树最左下的结点，

如在找b 的后继时，先沿右指针找到其右子树的根节点 e ，然后顺着 e 的左指针往下找一直找到左标志为 1 的结点，即为 b 的后继（图中e下面只有一层，如果是多层，也是一直往左找），所以可以看到图中g 的前驱为 b ，

如何找结点的前驱呢？
若其左标志为1，则左链为线索，指示其前驱。如图中 g 的前驱是b，c的前驱是a
若其左标志为0，则遍历左子树时最后访问的一个结点（左子树的右下角）为其前驱
如上图中，a 的前驱是h，因为a左子树最后访问的结点是h。

遍历这个中序线索链表如下紫色线条
在这里插入图片描述
在后序线索树中找结点的后继
可分三种情况

  1. 二叉树的根后继为空（后序遍历最后访问根）
  2. 若结点x 是双亲的右孩子， 或者是双亲的左孩子(当x为左孩子时双亲没有右子树)，其后继为双亲结点
  3. 若结点x 是双亲的左孩子，且其双亲有右子树，则其后继为双亲的右子树上按后序遍历列出的第一个结点。
    在这里插入图片描述
线索二叉树的存储表示

二叉树的二叉线索存储表示：

typedef int TElemType;
typedef int PointerTag;
typedef enum PointerTag{ Link, Thread};// Link == 0: 指针，Thread == 1: 线索

/*结点的定义*/
typedef struct BiThrNode{
	TElemType data;            //数据域
	BiThrNode *lchild, *rchild;//结点的左右孩子
	PointerTag LTag,RTag;      //标志域
}BiThrNode, *BiThrTree;

要获得线索二叉树，首先创建一个普通二叉链表树：

/*创建二叉树*/
BiThrTree CreateBiThrTree(BiThrTree BT){
	BT = (BiThrNode *)malloc(sizeof(BiThrNode));//分配存储空间
	if(!BT){
		printf("分配存储空间失败\n");
	}
	TElemType ch;

	scanf("%c",&ch);
	if(ch =='#'){
		BT = NULL;
	}else{
		BT->data = ch;
		BT->lchild = CreateBiThrTree(BT->lchild);
		BT->rchild = CreateBiThrTree(BT->rchild);
	}
	return BT;
}

然后再在遍历二叉树的时候将二叉树线索化，即将二叉链表中的控制很改为指向前驱或者后继的线索。

/*中序遍历进行线索化*/
void InThreading(BiThrTree T){
	BiThrTree preT;
	preT = (BiThrNode *)malloc(sizeof(BiThrNode));
	if(T){
		InThreading(T->lchild);//左子树线索化

		/*根节点线索化*/
		if(!T->lchild){//如果跟结点的左孩子为空
			T->LTag = Thread;//结点的左标志为1，指向前驱
			T->lchild = preT;//结点的左指针域指向前驱
		}
		if(!preT->rchild){//如果双亲结点没有右孩子
			T->RTag = Thread;//结点的右标志为1，指向后继
			preT->rchild = T;//结点的双亲结点的后继指向该结点
		}
		preT = T;//preT指向T 的前驱

		InThreading(T->rchild);
	}
}


/*将中序遍历二叉树并将其线索化*/
BiThrTree InOrderThreading(BiThrTree T){
	BiThrTree preT;
	
	preT = (BiThrNode *)malloc(sizeof(BiThrNode));

	BiThrTree Thr;//指向头节点
	if(!(Thr = (BiThrNode *)malloc(sizeof(BiThrNode)))) exit(-2);//分配存储空间
	//建立头节点
	Thr->LTag = Link;//左标志为0，指向左孩子
	Thr->RTag = Thread;//右标志为1，指向后继
	Thr->rchild = Thr;//右指针回指
	if(!T) Thr->lchild = Thr;//若二叉树为空，左指针回指
	else{
		Thr->lchild = T;//头节点的左孩子是根节点
		preT = Thr;
		InThreading(T);//中序遍历进行中序线索化
		preT->rchild = Thr;
		preT->RTag = Thread;//最后一个结点线索化
		Thr->rchild = preT;//
	}

	return T;
}

二叉树的遍历

遍历是二叉树各种操作的基础，可以在遍历过程中对节点进行各种操作。

顺着某一条搜索路径巡防二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次。

如果是线性表之类的线性结构而言，遍历很简单，因为只有一条搜索路径。但是二叉树是非线性结构，每个结点有两个后继，则存在如何遍历即按照什么样的搜索路径遍历的问题。
二叉树由以下三个部分组成。根节点，左子树，右子树
在这里插入图片描述
由二叉树的这种结构，一般遍历时都是先遍历左子树，再遍历右子树。
所以有三种方法（这三种方法都是二叉树不为空的前提下进行的）：

先（根）序遍历

  • 访问根节点
  • 先序遍历左子树
  • 先序遍历右子树
    在这里插入图片描述
    看一下遍历的代码：
#include <stdio.h>
#include <stdlib.h>
#define OVERFLOW -2

typedef char TElemType;

/*二叉树的结点结构*/
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

/*创建二叉树*/
BiTree CreateBiTree(BiTree T){
	/*分配存储空间*/
	T = (BiTNode *)malloc(sizeof(BiTNode));

	char ch;
	scanf("%c",&ch);
	//如果输入为空，则二叉树是空树
	if(ch=='#'){
		T = NULL;
	}else{
		if(!T){
			printf("分配存储空间失败！");
			exit(OVERFLOW);
		}
		T->data = ch;//先输入根结点
		T->lchild = CreateBiTree(T->lchild);//递归生成左子树
		T->rchild = CreateBiTree(T->rchild);//递归生成右子树
	}
	return T;
}	

void PrintElement(BiTree T){
	printf("%c\n",T->data);
}

/*先序遍历二叉树*/
void PreOrderTraverse(BiTree T){
	if(T){
	
		PrintElement(T);//先访问根结点
		PreOrderTraverse(T->lchild);//递归访问左子树
		PreOrderTraverse(T->rchild);//递归访问右子树
	}
	return;//如果树为空，返回上一次
}

int main(){
	/*创建二叉树*/
	BiTree T;
	printf("请输入二叉树中的元素 # 表示空\n");
	BiTree Tree = CreateBiTree(T);

	/*先序遍历二叉树*/
	printf("二叉树为:\n");
	PreOrderTraverse(Tree);
	return 0;
}

先序遍历结果：
在这里插入图片描述
二叉树的结构如下，# 代表这个节点为空：
在这里插入图片描述

中（根）序遍历

  • 中序遍历左子树
  • 访问根节点
  • 中序遍历右子树

在这里插入图片描述

原理和先序遍历一样：

......

void PrintElement(BiTree T){
	printf("%c\n",T->data);
}

/*中序遍历二叉树*/
void LastOrderTraverse(BiTree T){
	if(T){
	
		LastOrderTraverse(T->lchild);//递归访问左子树
		PrintElement(T);
		LastOrderTraverse(T->rchild);//递归访问右子树
	}
	return;//如果树为空，返回上一次
}

......

在这里插入图片描述

后（根）序遍历

  • 后序遍历左子树
  • 后序遍历右子树
  • 访问根节点

在这里插入图片描述

void PrintElement(BiTree T){
	printf("%c\n",T->data);
}

/*后序遍历二叉树*/
void PreOrderTraverse(BiTree T){
	if(T){
	
		PreOrderTraverse(T->lchild);//递归访问左子树
		
		PreOrderTraverse(T->rchild);//递归访问右子树
		PrintElement(T);
	}
	return;//如果树为空，返回上一次
}

在这里插入图片描述
看一个简单的例子：
在这里插入图片描述

层次遍历

按照二叉树中的层次从上到下，从左到右依次遍历每层中的结点
在这里插入图片描述
具体的实现思路是：
通过使用队列的数据结构，从树的根结点开始，依次将其左孩子和右孩子入队。而后每次队列中一个结点出队，都将其左孩子和右孩子入队，直到树中所有结点都出队，出队结点的先后顺序就是层次遍历的最终结果。

二叉树的相关操作

求二叉树的深度


/*求二叉树深度*/
int TreeDepth(BiTree T){
	int treedepth;//二叉树深度
	int ldepth;//左子树深度
	int rdepth;//右子树深度
	if(!T){
		treedepth = 0;
	}else{
		ldepth = TreeDepth(T->lchild);
		rdepth = TreeDepth(T->rchild);
		if(ldepth>rdepth){
			treedepth = ldepth + 1;
		}else{
			treedepth = rdepth + 1;
		}
	}
	return treedepth;
}

统计二叉树中叶子结点的个数

待添加

复制二叉树

待添加

树和森林

树的存储结构

双亲表示法

假设一组连续空间存储树的结点，同时在每一个结点中附设一个指示器指示其双亲结点在链表中的位置，

#define MAX_TREE_SIZE 100
//结点结构
typedef struct PTNode{
	TElemType data;//数据域
	int parent;  //双亲位置域
}PTNode;
//树结构
typedef struct {
	PTNode nodes[MAX_TREE_SIZE];
	int r,n;//树的位置和节点数
}PTree;

这种存储结构利用了除了根节点外每个结点只有一个双亲的性质，PARENT(T,x)操作可以在常量时间内实现，反复调用PARENT 操作，直到遇见无双亲的结点时，便找到了树的根，这就是ROOT(x)操作的执行方法，但是在这种表示法中，求结点的孩子时需要遍历整个结构。
在这里插入图片描述

孩子表示法

由于树中每个结点可能会有多课子树，则可以使用多重链表，即每个结点有多个指针域，其中每个指针指向一棵子树的根节点，此时链表中的结点可以有如下两种结点格式
在这里插入图片描述
采用上面这种结点格式，则多重链表中的结点是同构的，其中d 为树的度，由于树中很多结点的度小于d，所以链表中很多空链域，空间较浪费，在一颗有n 个结点的，度为k 的树中，必有n(k-1)+1 个空链域。
在这里插入图片描述
采用这种结点格式，多重链表中的结点是不同构的，其中d 为结点的度，degree 域的值同d，此时虽然节约存储空间，但是操作不方便。

还有一种方法是将每个结点的孩子结点排列起来，看成是一个线性表，且以单链表作为存储结构，n个结点有n个孩子链表，叶子的孩子链表为空表。而n个头指针又组成一个线性表，为了便于查找，可采用顺序存储结构，如下：

typedef struct CTNode{
	int child;
	struct CTNode *next;
}*ChildPtr;
typedef struct{
	TElemType data;
	ChildPtr firstchild;//孩子链表头指针
}CTBox;
typedef struct {
	CTBox nodes[MAX_TREE_SIZE];
	int n,r;//结点数和根的位置
}CTree;

森林和二叉树的转换

由于二叉树和树都可以用二叉链表作为存储结构，则以二叉链表作为媒介可以导出树与二叉树之间的一个对应关系。
也就是说，给定一棵树，可以找到唯一的一颗二叉树与之对应，从物理结构来看，他们的二叉链表是相同的，只是解释不同而已

树转换为二叉树

下面是一个树和二叉树的对应关系示例
在这里插入图片描述
树转换为二叉树的过程如下
在这里插入图片描述

从树的二叉链表表示的定义可知，任何一颗和树对应的二叉树，其右子树必定为空。
若把森林中第二棵树的根结点看成是第一棵树的根结点的兄弟，则同样可以到处森林和二叉树的对应关系。

一一对应的关系导致森林或树或二叉树可以相互转换，其形式定义如下；

二叉树转换为树

  1. 加线。若某结点的左孩子结点存在，则将这个孩子的右孩子结点、右孩子的右孩子结点、右孩子的右孩子的右孩子结点……，反正就是左孩子的n个右孩子结点都作为此结点的孩子。将该结点与这些右孩子结点用线连接起来。
  2. 去线。删除原二叉树中所有节点与右孩子结点的连线。
  3. 层次调整。使之结构层次分明。
    在这里插入图片描述

森林转换成二叉树

方法一
如果F= {T1,T2,····,Tm}是森林，可按如下规则转换成一棵二叉树，B = (root, LB, RB)。

  1. 若F为空，即m = 0，B为空树
  2. 若F非空，即m != 0，
    则B的根 root 几位森林中第一棵树的根 ROOT(T1)
    B的左子树LB是从T1的根结点的子树森林 F1 = {T1， T12， T1m1}转换而成的二叉树，
    B的右子树RB是从森林F` = {T2, T3, ······,Tm}转换而成的二叉树

方法二
1.把每棵树转换为二叉树（参考上述方法）。
2.第一棵二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子，用线连接起来。当所有的二叉树连接起来后就得到了由森林转换来的二叉树。在这里插入图片描述

二叉树转换成森林

方法一
如果B=(root,LB,RB) 是一颗二叉树，可按如下规则转换成森林

  1. 若B空，则F空
  2. 若B非空，则F中第一棵树T1 的根ROOT(T1)即为二叉树B的根root，T1 中根结点的子树森林F1是由B的左子树LB转换而成的森林，F中除T1之外其余树组成的森林 F` ={T2,T3,·····,Tm}是由B的右子树RB转换而成的森林。

方法二
判断一棵二叉树能够转换成一棵树还是森林，标准很简单，只要看这棵树的根结点有没有右孩子，有的话就是森林，没有的话就是一棵树。

将二叉树转换为森林的步骤如下：

  1. 从根结点开始，若右孩子存在，则将其与右孩子结点的连线删除，再查看分离后的二叉树，若右孩子存在，则连线删除……直到所有右孩子的连线都删除为止，得到分离后的二叉树。

  2. 将每棵分离后的二叉树转换为树即可。
    在这里插入图片描述

树和森林的遍历

树的遍历

由树的结构可以引出两种次序遍历树的方法，
一种是先根（次序）遍历树：先访问根结点，再依次先根遍历根的每棵子树；
另一种是后根（次序）遍历树：先依次后根遍历每棵子树，然后访问根结点。
这里没有中根遍历树，因为二叉树的根结点只有左子树和右子树两棵树，而树的根结点可能有多棵树。
在这里插入图片描述

森林的遍历

森林和树一样，也有两种遍历方法

  1. 先序遍历森林
    若森林非空，可以按照下述规则遍历：

    1. 访问森林中第一棵树的根结点
    2. 先序遍历第一棵树中根结点的子树森林
    3. 先序遍历除去第一棵树之后剩余的树构成的森林

  2. 中序遍历森林
    若森林非空，按照如下规则遍历

    1. 中序遍历森林中第一棵树的根结点的子树森林
    2. 访问第一棵树的根结点
    3. 中序遍历除去第一棵树之后剩余的树构成的森林
      在这里插入图片描述

当森林转换成二叉树时，其第一颗树的子树森林转换成左子树，剩余树的森林转换成右子树，则上述森林的先序和中序遍历即为其对应的二叉树的先序和中序遍历。
由此可见，当以二叉链表作树的存储结构时，树的先根遍历和后根遍历可借用二叉树的先序遍历和中序遍历算法实现。

赫夫曼树及其应用

赫夫曼树又称最优树，是一类带权路径长度最短的树

赫夫曼树

路径：从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径
路径长度：路径上的分支数目称作路径长度。
树的路径长度：从树根到每一个结点的路径长度之和。完全二叉树就是路径长度最短的二叉树
结点的带权路径长度：该节点到树根之间的路径长度与结点上权的乘积
树的带权路径长度：树中所有叶子节点的带权路径长度之和 通常记作
在这里插入图片描述
在这里插入图片描述
赫夫曼树： 假设有n个权值(w1,w2…wn)，试构造一棵有n个叶子结点的二叉树，每个叶子结点带权为wi ，则其中带权路径长度WPL最小的二叉树称作最优二叉树或赫夫曼树。

赫夫曼树的特点
  1. 权值越大的叶子节点越靠近根结点，权值越小的叶子节点越远离根结点。
  2. 只有度为0（叶子节点）和度为2的（分支节点）的结点，不存在度为1 的结点

构造赫夫曼树/赫夫曼算法

赫夫曼最早给出了一个带有一般规律的算法，俗称赫夫曼算法。
基本思想：

  1. 初始化
    由给定的n 个权值{w1, w2,···,wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F={T1, T2, ···, Tn}；
  2. 选取与合并
    在F 中选取根结点的权值最小的两棵二叉树分别作为左，右子树构造一棵新的二叉树，这棵新的二叉树的根节点的权值为其左右子树根节点的权值之和。
  3. 删除与加入
    在F中删除作为左右子树的两棵二叉树，并将新建立的二叉树加入到F 中；
  4. 重复2.3 步骤，当集合F中 只剩下一棵二叉树时，这棵二叉树就是哈夫曼树

演示一下：

  • 在这里插入图片描述
    重复上面步骤：
    在这里插入图片描述

赫夫曼树存储

存储结构

struct element{
	int weight;
	int lchild, rchild, parent;
};

设置一个数据huffTree[2n-1] 保存赫夫曼树中个点信息，数组元素的结点结构
在这里插入图片描述
weight : 权值域，保存该节点的权值
lchild: 指针域，结点的左孩子结点在数组中的下标
rchild: 指针域，结点的右孩子结点在数组中的下标
parent: 指针域，该节点的双亲结点在数组中的下标

为何存储数组的元素个数为 2n - 1

在这里插入图片描述
过程演示：
因为有四个元素，所以分配7个内存空间：

在这里插入图片描述
初始化：
每一棵树都是一个根节点，没有双亲也没有孩子
在这里插入图片描述
填入权值：

在这里插入图片描述
找到权值最小，且parent 为 -1 的两个结点合并，并修改其parent 值
在这里插入图片描述
修改k对应的左孩子右孩子对应的值：
在这里插入图片描述
继续循环，这里有两个5，扫描的时候会先选中前面的结点：
在这里插入图片描述
再循环：
在这里插入图片描述
伪代码：
在这里插入图片描述

在这里插入图片描述

风吹我亦散
关注
  • 28
    点赞
  • 踩
  • 164
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言数据结构之图的遍历实例详解
08-30
"C语言数据结构之图的遍历实例详解" 本文主要介绍了C语言数据结构之图的遍历实例详解的相关知识点，包括图的遍历算法、图的存储结构、图的遍历实现等。 一、图的遍历算法 图的遍历算法是指从图的一点出发，遍历图...
数据结构——树（C语言）
love_fufu_7572的博客
04-05 1031
树（Tree）是计算机数据结构中的一种非常重要的抽象数据类型，它是一种分层数据的集合。在树结构中，数据以节点（Node）的形式存储，并且每个节点都可以有零个或多个子节点。这种结构类似于现实生活中树，因此得名。
数据结构（C语言）-树
czh2637750821的博客
03-04 2823
树一、树1、树的定义2、树的基本术语3、树结构和线性结构的比较二、二叉树1、二叉树的定义2、二叉树的形态与树的形态3、二叉树的性质4 、二叉树的存储结构 一、树 1、树的定义 （1）树的定义 树（Tree）n(n>=0)个有限数据元素的集合。当n=0时称为空树。当n>0时，是非空树，它满足以下两个条件： （2）树的表示方法 树的逻辑结构表示主要有四种：树形表示法，嵌套集合表示法，凹入表示法和广义表表示法等 2、树的基本术语 3、树结构和线性结构的比较 二、二叉树 1、二叉树的定义
树形结构C语言的实现
最新发布
2301_81689298的博客
07-05 670
树形结构是一层次的嵌套结构。一个树形结构的外层和内层有相似的结构，所以这种结构多可以递归的表示。经典数据结构中的各种树状图是一种典型的树形结构：一棵树可以简单的表示为根，左子树，右子树。左子树和右子树又有自己的子树。
【C语言】数据结构——树
weixin_45423515的博客
05-23 4297
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的 一、树的概念 概念： ※节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的度为2。 ※叶节点或终端节点：度为0的节点称为叶节点； 如上图：E、F、G、H...等节点为叶节点。 非终端节点或分支节点：度不为0的节点； 如上图：B、C、D...等节点为分支节点 ※双亲节点或父节点：......
C语言数据结构之树（保姆级讲解）
Qurry的博客
11-21 2686
树是“一对多”的非线性存储结构，较链表、队列那些，树的概念会多点，涵盖的范围也较广。由根节点和若干子树构成；单个节点也可以看成树，只有一个树根节点
《数据结构》(7) - 树和二叉树
weixin_52142420的博客
08-27 468
文章目录前言一、树概念及结构1.树的概念2.树的特点3.树的相关名词二、树的表示1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、树概念及结构 1.树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上.
数据结构-树（c语言实现篇）
CHAKMING1的博客
07-29 3318
数据结构之二叉树（c语言实现篇）
C语言数据结构之 折半查找实例详解
12-31
语言：数据结构C语言版 编译环境：VC++ 6.0 日期： 2014-3-26 */ #include #include #include <windows> #define N 11 // 数据元素个数 typedef int KeyType; // 设关键字域为整型 typedef struct // 数据...
C语言数据结构树的双亲表示法实例详解
01-20
2、/* bo6-4.c 树的双亲表存储(存储结构由c6-4.h定义)的基本操作(14个) */ Status InitTree(PTree *T) { /* 操作结果: 构造空树T */ (*T).n=0; return OK; } void DestroyTree() { /* 由于PTree是定长类型,...
C语言数据结构 快速排序实例详解
12-31
C语言数据结构 快速排序实例详解 一、快速排序简介 快速排序采用分治的思想，第一趟先将一串数字分为两部分，第一部分的数值都比第二部分要小，然后按照这种方法，依次对两边的数据进行排序。 二、代码实现 #...
c语言实现数据结构--树
bhbca的博客
01-17 2061
C语言实现树
【数据结构】树（一）—— 树的基础知识（C语言版）
haoweixl的博客
05-09 2051
树的基础知识树的定义树的相关概念度(Degree)结点间的关系结点的 层次(Level)有序树与森林线性表和树的不同树的抽象数据类型树的存储结构双亲表示法双亲表示法的优化孩子表示法孩子兄弟表示法 树的定义 树(Tree)是 n(n≥0)个结点的有限集。 n=0 时称为空树。 在任意一颗非空树中： （1）有且仅有一个特定的称为根(Root)的结点 （2）当 n>1时，其余结点可分为 m(m>0)个互不相交的有限集 T1、T2、…、Tm， 其中每一个集合本身又是一棵树，并且称为根的子树(SubTre
C语言 · FBI树
weixin_34260991的博客
04-05 311
算法训练 FBI树   时间限制：1.0s   内存限制：256.0MB        锦囊1 　　二叉树。 问题描述 　　我们可以把由“0”和“1”组成的字符串分为三类：全“0”串称为B串，全“1”串称为I串，既含“0”又含“1”的串则称为F串。　　FBI树是一种二叉树，它的结点类型也包括F结点，B结点和I结点三种。由一个长度为2N的“01”串S可以构造出一棵FBI树T，递归的构造方法...
数据结构之“树”（c语言实现）
cherin_的博客
01-11 903
树的基础介绍，适合初学者
C语言数据结构———树
JXLike2014的博客
08-17 89
1. 二叉树有0个或1个或2个直接后继节点且严格区分左右即使只有一个子节点也要区分左右。满二叉树: 除叶子节点外 其他有所节点 都有两个 直接后继 且 叶子节点都在最后一层。子节点: 树结构中 除根节点外 其他节点都称作 子节点。树的深度: 从根开始 到每一个叶子节点 最长的经过的节点 个数。根节点: 树的起始位置 一棵树 一定有根节点。树的路径: 从根节点开始 到目标节点 经过的节点顺序。叶子节点: 特殊的子节点, 没有后继的 子节点。
c语言树跟图,数据结构（十） -- C语言版 -- 树 - 基础知识
weixin_42261886的博客
05-19 956
内容预览零、读前说明一、树的定义二、树中的概念三、树的表示法四、树的特点零、读前说明本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。设计的代码并非全部公开，部分无关紧要代码并没有贴出来。如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎...
数据结构（十） -- C语言版 -- 树 - 基础知识
青椒*^_^*凤爪爪的博客
05-13 6752
本文中没有涉及到很多的相关理论知识，也没有做深入的了解，所以，您如果是想要系统的学习、想要多学习关于理论的知识等，那么本文可能并不合适您。 本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
树（C语言）
过客的博客
08-29 9104
文章目录树树的定义树的一些基本术语树的表示 树 树的定义 树（Tree）：n(n≥0)n(n \geq 0)n(n≥0)个结点构成的有限集合。当n=0时，称为空树。 对于任一棵非空树（n&gt;0n&gt;0n>0）,它具有以下性质： 树中有一个称为“根（Root）”的特殊结点，用r表示； 其余结点可分为m(m&gt;0)m(m&gt;0)m(m&g...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值