第五章 树与二叉树

原创 已于 2024-11-11 00:56:19 修改
· 1.5k 阅读 · 30 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #考研 #学习

于 2024-01-27 23:39:40 首次发布

文章目录


注：内容参考王道2024考研复习指导以及《数据结构》

树的基本概念

树的定义

树是 n ( n > 0 ) n(n > 0) n(n>0)个结点的有限集合， n = 0 n=0 n=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足：

  1. 有且仅有一个特定的称为根的结点。
  2. 当 n > 1 n > 1 n>1时，其余结点可分为 m ( m > 0 ) m(m > 0) m(m>0)个互不相交的有限集合 T 1 , T 2 , . . . , T m T_1,T_2,...,T_m T1​,T2​,...,Tm​，其中每个集合本身又是一棵树，并且称为根结点的子树。

树，是一种递归定义的数据结构，作为一种逻辑结构，也是一种分层结构，具有以下两个特点：

  1. 树的根结点没有前驱，除根结点以外的所有结点有且只有一个前驱。
  2. 树中所有结点都可以具有零个或多个后继。

基本术语

结点之间的关系描述

1）双亲：上层的那个结点，直接前驱。

2）孩子：下层结点的子树的根，直接后继。

3）兄弟：同一双亲下的同层结点 ，孩子之间互称兄弟。

4）堂兄弟：双亲位于同一层的结点，但并非同一双亲。

5）祖先：从根到该结点所经分支的所有结点。

6）子孙：该结点下层子树中的任一结点。

结点、树的属性描述

1）结点的度：结点拥有的子树数称为结点的度。

2）树的度：所有结点的度中的最大值。

3）结点的层次：从根结点开始定义，默认从 1 1 1开始，任一结点的等于其双亲结点的层次加 1 1 1。

4）结点的高度：以该结点为根的子树的高度。

5）树的高度：树中结点的最大层次称为树的高度或深度。

6）树的路径长度：树根到每个结点的路径长的总和。

有序树和无序树

1）有序树：逻辑上看，树中结点的各子树从左至右是有次序的，不能互换。

2）无序树：逻辑上看，树中结点的各子树从左至右是无次序的，可以互换

森林

森林是 m ( m ≥ 0 ) m(m \geq 0) m(m≥0)棵互不相交的树的集合。

注：需要掌握树和森林相互转化的问题。

树的性质

  • 树的结点数=所有结点度数之和 + 1 +1 +1。

  • 度为 m m m的树和 m m m叉树的区别：

    image-20240310184337907

  • 度为 m m m的树第 i i i层至多有 m i − 1 m^{i-1} mi−1个结点， m m m叉树第 i i i层至多有 m i − 1 m^{i-1} mi−1个结点 ( i ≥ 1 ) (i \geq 1) (i≥1)。

  • 高度为 h h h的 m m m叉树至多有 m h − 1 m − 1 \frac{m^h-1}{m-1} m−1mh−1​个结点。

  • 高度为 h h h的 m m m叉树至少有 h h h个结点。

  • 高度为 h h h、度为 m m m的树至少有 h + m − 1 h+m-1 h+m−1个结点。

  • 度为 m m m、具有 n n n个结点的树的最大高度 h = n − m + 1 h=n-m+1 h=n−m+1。

  • 度为 m m m、具有 n n n个结点的树的最小高度 h = ⌈ log ⁡ m ( n ( m − 1 ) ) + 1 ⌉ h=\lceil{\log_m(n(m-1))+1}\rceil h=⌈logm​(n(m−1))+1⌉。高度最小的情况：所有结点都有 m m m个孩子（即 m m m叉树）

二叉树的概念

二叉树的定义及其主要特性

二叉树的定义

二叉树（Binary Tree）是 n ( n ≥ 0 ) n(n \geq 0) n(n≥0)个结点所构成的集合，它或为空树 ( n = 0 ) (n = 0) (n=0)；或为非空树，对于非空树 T T T：

  1. 有且仅有一个称之为根的结点；
  2. 除根结点以外的其余结点分为两个互不相交的子集 T 1 T_1 T1​和 T 2 T_2 T2​，分别称为 T T T的左子树和右子树，且 T 1 T_1 T1​和 T 2 T_2 T2​本身又都是二叉树。

特点：1）每个结点至多只有两棵子树；2）左右子树不能颠倒（二叉树是有序树）。

二叉树的五种状态

image-20240125093423711

二叉树的性质

  • 设非空二叉树中度为 0 , 1 , 2 0,1,2 0,1,2的结点个数分别为 n 0 , n 1 , n 2 n_0,n_1,n_2 n0​,n1​,n2​，则 n 0 = n 2 + 1 n_0=n_2+1 n0​=n2​+1（叶子结点比分支结点多一个）。
  • 二叉树第 i i i层至多有 2 i − 1 2^{i-1} 2i−1个结点。
  • 高度为 h h h的二叉树至多有 2 h − 1 2^h - 1 2h−1个结点（满二叉树）。

特殊的二叉树

1）满二叉树：一棵高度为 h h h，且含有 2 h − 1 2^h-1 2h−1个结点的二叉树。

image-20240125093842921

特点：1）只有最后一层有叶子结点；2）不存在度为 1 1 1的结点；3）按层序从 1 1 1开始编号，结点 i i i的左孩子为 2 i 2i 2i，右孩子为 2 i + 1 2i+1 2i+1；结点 i i i的父节点为 ⌊ i / 2 ⌋ \lfloor {i/2} \rfloor ⌊i/2⌋ （如果有的话）

2）完全二叉树：当且仅当其每个结点都与高度为 h h h的满二叉树中编号为 1 ∼ n 1 \sim n 1∼n的结点一一对应时，称为完全二叉树。

image-20240125094113183

特点：1）只有最后两层可能有叶子结点；2）最多只有一个度为 1 1 1的结点；3）按层序从 1 1 1开始编号，结点 i i i的左孩子为 2 i 2i 2i，右孩子为 2 i + 1 2i+1 2i+1；结点 i i i的父节点为 ⌊ i / 2 ⌋ \lfloor {i/2} \rfloor ⌊i/2⌋ （如果有的话）；4） i ≤ ⌊ n / 2 ⌋ i \leq \lfloor {n/2} \rfloor i≤⌊n/2⌋ 为分支结点， i > ⌊ n / 2 ⌋ i > \lfloor {n/2} \rfloor i>⌊n/2⌋ 为叶子结点。

完全二叉树的性质

  • 具有 n n n个结点的完全二叉树的高度 h = ⌈ log ⁡ 2 n + 1 ⌉ h=\lceil {\log_2{n+1} \rceil} h=⌈log2​n+1⌉或 ⌊ log ⁡ 2 n ⌋ + 1 \lfloor {\log_2n} \rfloor+1 ⌊log2​n⌋+1
  • 对于完全二叉树，可以由的结点数 n n n推出度为 0 , 1 , 2 0,1,2 0,1,2的结点个数为 n 0 , n 1 , n 2 n_0,n_1,n_2 n0​,n1​,n2​
    • 若完全二叉树有 2 k 2k 2k个（偶数）个结点，则必有 n 1 = 1 , n 0 = k , n 2 = k − 1 n_1=1,n_0=k,n_2=k-1 n1​=1,n0​=k,n2​=k−1。
    • 若完全二叉树有 2 k − 1 2k-1 2k−1个（奇数）个结点，则必有 n 1 = 0 , n 0 = k , n 2 = k − 1 n_1=0,n_0=k,n_2=k-1 n1​=0,n0​=k,n2​=k−1。

3）二叉排序树：左子树上所有结点的关键字均小于根结点的关键字；右子树上所有结点的关键字均大于根结点的关键字；左子树和右子树又各是一棵二叉排序树。

image-20240125094354707

注：注意定义是左右子树上的所有结点，而不是左右孩子结点。

4）平衡二叉树：树上任一结点的左子树和右子树的深度之差不超过 1 1 1。

image-20240125094600364

5）正则二叉树：树中每个分支结点都有 2 2 2个孩子，即树中只有度为 0 0 0或为 2 2 2的结点。

二叉树的存储结构

顺序存储

定义一个长度为MaxSize的数组t，按照从上到下、从左到右的顺序依次存储完全二叉树中的各个结点。

#define MaxSize 100
typedef struct TreeNode{
    ElemType value;
    bool isEmpty;
}TreeNode;
TreeNode t[MaxSize];

image-20240125103016804

特点：1）结点间关系蕴含在其存储位置中；2）对于一般二叉树浪费空间，适于存满二叉树和完全二叉树。

链式存储

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

image-20240312204156458

特点： n n n个结点的二叉链表共有 n + 1 n+1 n+1个空链域。

注： n n n个结点必有 2 n 2n 2n个链域,除根结点外，每个结点有且仅有一个双亲，所以只会有 n − 1 n-1 n−1个结点的链域存放指针，指向非空孩子结点。

为了方便查找指定结点的父结点，我们可以添加一个父结点指针，形成三叉链表。

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
	struct BiTNode *parent;
}BiTNode,*BiTree;

二叉树的遍历

什么是遍历

遍历定义：遍历定义一顺着某一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次(又称周游)。

遍历目的：得到树中所有结点的一个线性排列。

遍历用途：它是树结构插入、删除、修改、查找和排序运算的前提，是二叉树一切运算的基础和核心。

二叉树的先序遍历

先序遍历：根左右（NLR）

中序遍历：左根右（LNR）

后序遍历：左右根（LRN）

注：后序遍历退回时访问根结点，这样可以从下到上把祖先到子孙的路径输出。

image-20240125104320559

代码实现

/*
先序遍历代码如下，
对于中序遍历（InOrder）和后序遍历（PostOrder），
只需要调整visit()函数的位置即可实现对应规则的遍历。
*/
void PreOrder(BiTree T){//先序遍历（PreOrder）
    if(T!=NULL){
        visit(T);//内部规定访问结点后需要做的事情
        PreOrder(T->lchild);//递归遍历左子树
        PreOrder(T->rchild);//递归遍历右子树
    }
}

不管采用哪种遍历算法，每个结点都访问一次且仅访问一次，所以时间复杂度都是 O ( n ) O(n) O(n)。

在递归遍历中，递归工作栈的栈深恰好为树的深度，所以在最坏情况下，二叉树是有 n n n个结点且深度为 n n n的单支树，遍历算法的空间复杂度为 O ( n ) O(n) O(n)。

非递归代码实现

void PreOrder(BiTree T){
    InitStack(S);
    BiTree p=T;
    while(p || !IsEmpty(S)){
        if(P){
            visit(p);
            Push(S,p);
            p=p->lchild;
        }else{
            Pop(S,p);
            p=p->rchild;
        }
    }
}

应用

//求树的深度
int treeDepth(BiTree T){
    if(T == NULL){
        return 0;
    }else{
        int l=treeDepth(T->lchild);
        int r=treeDepth(T->rchild);
        return l>r ? l+1:r+1;
    }
}

二叉树的层序遍历

算法思想：

  1. 初始化一个辅助队列；
  2. 根结点入队；
  3. 若队列非空，则队头结点出队，访问该结点，并将其左、右孩子插入队尾（如果有的话）；
  4. 重复步骤3直至队列为空。

image-20240127223307501

代码实现：

typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,rchild;
}BiTNode,*BiTree;

typedef struct LinkQueue{
    BiTNode *data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front,*rear;
}LinkQueue;

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);
        }
    }
}

遍历序列构造二叉树

若二叉树中各结点的值均不相同,则二叉树结点的前序序列、中序序列和后序序列都是唯一的。

若只给出一棵二叉树的前/中/后/层序遍历序列中的一种，不能唯一确定一棵二叉树。

前序、后序、层序序列的两两组合无法唯一确定一棵二叉树。

关键：找到树的根节点，并根据中序序列划分左右子树，再找到左右子树根节点。

  • 前序+中序遍历序列

    image-20240127224145584

  • 后序+中序遍历序列

    image-20240127224318227

  • 层次+中序遍历序列

    image-20240127224400607

线索二叉树

线索二叉树的基本概念

普通二叉树只能找到结点的左右孩子信息，而该结点的直接前驱和直接后继只能在遍历过程中获得。

若将遍历后对应的有关前驱和后继预存起来，则从第一个结点开始就能很快“顺藤摸瓜”而遍历整个树。

  • 若结点有左子树，则lchild指向其左孩子；否则，lchild指向其直接前驱(即线索)。
  • 若结点有右子树，则rchild指向其右孩子；否则，rchild指向其直接后继(即线索) 。

image-20240127224624001

typedef struct ThreadNode{
    ElemType data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;
}ThreadNode,*ThreadTree;

中序线索二叉树的构造

二叉树的线索化是将二叉链表中的空指针改为指向前驱或后继的线索，而前驱或后继的信息只有在遍历时才能得到，因此线索化的实质就是遍历一次二叉树。

ThreadNode *pre=NULL; 

void CreateInThread(ThreadTree T){
    pre=NULL;
    if(T!=NULL){
        InThread(T);
        //处理遍历的最后一个结点
        if(pre->rchild=NULL){
            pre->rtag=1;
        }
    }
}

//PostThread只需要调整visit函数的位置即可实现
void InThread(ThreadTree T){
    if(T!=NULL){
        InThread(T->lchild);
        visit(T);
        InThread(T->rchild);
    }
}

void PreThread(ThreadTree T){
    if(T!=NULL){
        visit(T);
        //前序遍历时，需要确保左孩子不是前驱线索，才可以进行左子树遍历，否则会进入死循环
        if(T-lchild==0){
            PreThread(T->lchild);
        }
        PreThread(T->rchild);
    }
}

void visit(ThreadTNode *q){
    if(q->lchild==NULL){
        q->lchild=pre;
        q->ltag=1;
    }
    //如果前驱不为空，且前驱右孩子为空，则前驱的右孩子指向当前结点
    if(pre!=NULL && pre->rchild==NULL ){
       	pre->rchild=q;
        pre->rtag=1;
    }
    pre=q;
}

线索二叉树的遍历

image-20240127233736266

中序线索二叉树的遍历

  • 查找p指针所指结点的前驱

    1. 若p->LTag==1，则p的左链指示其前驱。
    2. 若p->LTag==0，则说明p有左子树，结点的前驱是遍历左子树时访问的最后一个结点，即左子树中最右下的结点。

  • 查找p指针所指结点的后继

    1. 若p->RTag==1，则p的右链指示其后继。
    2. 若p->RTag==0，则说明p有右子树，结点的后继是遍历右子树时访问的第一个结点，即右子树中最左下的结点。
//找到以P为根的子树中，最后一个被中序遍历的点
ThreadNode *Lastnode(ThreadNode *p){
    while(p->rtag==0)	p=p->rchild;
    return p;
}
//找到结点P的前驱结点
ThreadNode *Prenode(ThreadNode *p){
    if(p->ltag==0)	return Lastnode(p->lchild);
    else	return p->lchild;
}
//对中序线索二叉树进行逆向中序遍历
void RevInorder(ThreadNode *T){
    for(ThreadNode *p=Lastnode(T);p!=NULL;p=Prenode(p))
        visit(p);
}

先序线索二叉树的遍历

  • 查找p指针所指结点的前驱

    1. 若p->LTag==1，则p的左链指示其前驱;
    2. 若p->Ltag==0，需改用三叉链表才可以找到父结点。
      • 如果能找到p的父结点且p是左孩子，p的父结点即为其前驱。
      • 如果能找到p的父结点，且p是右孩子，其左兄弟为空，p的父结点即为其前驱。
      • 如果能找到p的父结点，且p是右孩子，其左兄弟非空，p前驱为左兄弟子树中最后一个遍历的结点。
      • 如果p是根结点，则没有前驱

  • 查找p指针所指结点的后继

    1. 若p->RTag==1，则p的右链指示其后继
    2. 若p->RTag==0，则说明p有右子树。按先序遍历的规则可知，p的后继必为其左子树根（若存在）或右子树根。

后序线索二叉树的遍历

  • 查找p指针所指结点的前驱

    1. 若p->LTag==1，则p的左链指示其前驱。
    2. 若p->LTag==0
      • 若p->RTag==0时，则p的右链指示其前驱。
      • 若p->RTag==1时，则p的左链指示其前驱。

  • 查找p指针所指结点的后继

    1. 若p->RTag==1，则p的右链指示其后继。
    2. 若p->Rtag==0，需改用三叉链表才可以找到父结点。
      • 如果能找到p的父结点，且p是右孩子，p的父结点即为其后继。
      • 如果能找到p的父结点，且p是左孩子，其右兄弟为空，p的父结点即为其后继。
      • 如果能找到p的父结点，且p是左孩子，其右兄弟非空，p后继为右兄弟子树中最后一个遍历的结点。
      • 如果p是根结点，则没有后继

树、森林

树的逻辑结构

树：树是 n ( n ≥ 0 ) n(n \geq 0) n(n≥0)个结点的有限集合， n = 0 n=0 n=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足：

  1. 有且仅有一个特定的称为根的结点。
  2. 当 n > 1 n>1 n>1时，其余结点可分为 m ( m > 0 ) m(m >0) m(m>0)个互不相交的有限集合 T 1 , T 2 , . . . , T m T_1,T_2,...,T_m T1​,T2​,...,Tm​，其中每个集合本身又是一棵树，并且称为根结点的子树。

image-20240128105945514

森林： m ( m ≥ 0 ) m (m \geq 0) m(m≥0)棵互不相交的树的集合。

image-20240128110003550

树的存储结构

双亲表示法

用数组顺序存储各个结点。每个结点中保存数据元素、指向双亲结点（父节点）的“指针”。

优点：找双亲（父节点）很方便。

缺点：找孩子不方便，只能从头到尾遍历整个数组。

适用于“找父亲” 多，“找孩子” 少 的应用场景。如：并查集。

image-20240128113120437

#define MAX_TREE_SIZE 100
typedef struct{
    ElemType data;
    int parent;
}PTNode;
typedef struct{
    PTNode nodes[MAX_TREE_SIZE];
    int n;
}PTree;

注：树的顺序存储结构中，数组下标表示结点的编号，下标中所存的内容表示结点直接的关系；而二叉树的顺序存储中，数组下标即表示结点的编号，也表示了结点之间的关系。

注：用双亲表示法存储”森林“时，需要将每棵树的根节点双亲指针 = -1。

孩子表示法

用数组顺序存储树中各个结点。每个结点中保存数据元素、孩子链表头指针。

顺序存储+链式存储结合。

优点：找孩子很方便。

缺点：找双亲（父节点）不方便，只能遍历每个链表。

适用于“找孩子” 多，“找父亲” 少 的应用场景。如：服务流程树。

image-20240128113505339

struct CTNode{
    int child;
    struct CTNOde *next;
};
typedef struct{
    ElemType data;
    struct CTNode *firstChild;
}CTBox;
typedef struct{
    CTBox nodes[MAX_TREE_SIZE];
    int n,r;
}CTree;

注：用孩子表示法存储森林，需要记录多个根的位置。

孩子兄弟表示法

树的孩子兄弟表示法，与二叉树类似，采用二叉链表实现。每个结点内保存数据元素和两个指针，但两个指针的含义与二叉树结点不同。

image-20240128114140785

typedef struct CSNode{
    ElemType data;
    struct CSNode *firstChild,*nextsibling;
}CSNode,*CSTree;

最大优点是可以方便实现树转换为二叉树的操作，易于查找结点的孩子等，但缺点是查找双亲比较麻烦（可以为每个结点增设一个双亲指针）。

注：当使用“孩子兄弟表示法”存储树或森林时，从存储视角来看形态上与二叉树类似。

树、森林与二叉树的转换

树转换二叉树

对于一般的树，可以方便地转换成一棵唯一的二叉树与之对应，其详细步骤是：

  1. 在兄弟结点之间加一连线
  2. 对每个结点，只保留它与第一个孩子的连线，与其他孩子的连线全部抹掉
  3. 以树根为轴心，顺时针旋转 4 5 。 45^。 45。

特点：二叉树的根结点没有右子树，只有左子树；左子结点仍然是原来树中相应结点的左子结点，而所有沿右链往下的右子结点均是原来树中该结点的兄弟结点。

image-20240128115343757

森林转二叉树

将森林中各棵树的根节点视为平级的兄弟关系。

image-20240128115422648

二叉树转树

  1. 先画出树的根节点
  2. 从树的根节点开始，按“树的层序”恢复每个结点的孩子。在二叉树中，如果当前处理的结点有左孩子，就把左孩子和“一整串右指针糖葫芦” 拆下来，按顺序挂在当前结点的下方。

image-20240128115536799

二叉树转森林

  1. 先把二叉树的根节点和“一整串右指针糖葫芦”拆下来，作为多棵树的根节点
  2. 按“森林的层序”恢复每个结点的孩子。在二叉树中，如果当前处理的结点有左孩子，就把左孩子和“一整串右指针糖葫芦” 拆下来，按顺序挂在当前结点的下方。

image-20240128115645765

树、森林的遍历

树的先根遍历

（深度优先遍历）

若树非空，先访问根结点，再依次对每棵子树进行先根遍历。

树的先根遍历序列与这棵树相应二叉树的先序序列相同。

void PreOrder(TreeNode*R){
    if(R!=NULL){
        visit(R);//访问根节点
        while（R还有下一个子树T）
            Pre0rder(T);//先根遍历下一棵子树
    }
}

树的后根遍历

（深度优先遍历）

若树非空，先依次对每棵子树进行后根遍历，最后再访问根结点。

树的后根遍历序列与这棵树相应二叉树的中序序列相同。

树的层次遍历

（广度优先遍历）

  1. 若树非空，则根节点入队
  2. 若队列非空，队头元素出队并访问，同时将该元素的孩子依次入队
  3. 重复2直到队列为空

森林的先序遍历

若森林为非空，则按如下规则进行遍历（依次对各个树进行先根遍历或依次对森林对应的二叉树的先序遍历）：

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

森林的中序遍历

若森林为非空，则按如下规则进行遍历（依次对各个树进行后根遍历或依次对二叉树的中序遍历）：

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

注：当森林转换成二叉树时，其第一棵树的子树森林转换成左子树，剩余树的森林转换成右子树，可知森林的先序和中序遍历即为其对应二叉树的先序和中序遍历。

树和森林的遍历与二叉树的遍历关系如下：

image-20240313104220691

树与二叉树的应用

哈夫曼树和哈夫曼编码

哈夫曼树的定义

结点的权：有某种现实含义的数值（如：表示结点的重要性等）。

结点的带权路径长度：从树的根到该结点的路径长度（经过的边数）与该结点上权值的乘积。

树的带权路径长度：树中所有叶结点的带权路径长度之和（WPL, Weighted Path Length）。

在含有n个带权叶结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。

哈夫曼树的构造

给定n个权值分别为w1, w2,…, wn的结点，构造哈夫曼树的算法描述如下：

  1. 将这n个结点分别作为n棵仅含一个结点的二叉树，构成森林F。

  2. 构造一个新结点，从F中选取两棵根结点权值最小的树作为新结点的左、右子树，并且将新
    结点的权值置为左、右子树上根结点的权值之和。

  3. 从F中删除刚才选出的两棵树，同时将新得到的树加入F中。

  4. 重复步骤2和3，直至F中只剩下一棵树为止。

image-20240128142408778
特点：

  1. 每个初始结点最终都成为叶结点，且权值越小的结点到根结点的路径长度越大
  2. 构造过程中新建了n-1个结点，哈夫曼树的结点总数为2n−1
  3. 哈夫曼树中不存在度为1的结点。
  4. 哈夫曼树并不唯一，但WPL必然相同且为最优

哈夫曼编码

哈夫曼树不唯一，因此哈夫曼编码不唯一；哈夫曼编码可用于数据压缩。

固定长度编码，每个字符用相等长度的二进制位表示。

可变长度编码，允许对不同字符用不等长的二进制位表示。

前缀编码，若没有一个编码是另一个编码的前缀，则称这样的编码为前缀编码。

由哈夫曼树得到哈夫曼编码——字符集中的每个字符作为一个叶子结点，各个字符出现的频度作为结点的权值，根据之前介绍的方法构造哈夫曼树。

image-20240313161921044

并查集

并查集的概念

并查集是一种简单的集合表示，它支持以下3种操作：

  1. Initial（S）：将集合s中的每个元素都初始化为只有一个单元素的子集合。
  2. Union（S，Rootl，Root2）：把集合S中的子集合Root2并入子集合Rootl。要求Root1和Root2互不相交，否则不执行合并。
  3. Find（S，x）：查找集合s中单元素x所在的子集合，并返回该子集合的根结点。

并查集的存储结构

将各个元素划分为若干个互不相交的子集。

image-20240128142833105

用森林，也即互不相交的树，表示多个”集合“。

image-20240128142918927

用一个数组S[]表示”集合“关系

image-20240128143309000

并查集的基本实现

//结构定义
#define SIZE 13
int UFSets[SIZE];

//并查集初始化操作
void Initial(int S[]){
    for(int i=0;i<SIZE;i++){
        S[i]=-1;
    }
}

如何“查”到一个元素到底属于哪一个集合？从指定元素出发，一路向北，找到根节点。

//并查集的Find操作
int Find(int S[],int x){
    while(S[x]>=0){
        x=S[x];
    }
    return x;
}

如何把两个集合“并”为一个集合？让一棵树成为另一棵树的子树即可。

//并查集的Union操作
void Union(int S[],int Root1,int Root2){
    if(Root1==Root2){
        return ;
    }
    S[Root2]=Root1;
}

时间复杂度分析

查操作最坏时间复杂度为 O ( n ) O(n) O(n)；并操作时间复杂度为 O ( 1 ) O(1) O(1)。

并查集实现的优化

Union操作优化思路

在每次Union操作构建树的时候，尽可能让树不长高。

  1. 用根节点的绝对值表示树的结点总数；
  2. Union操作，让小树合并到大树。
void Union(int S[],int Root1,int Root2){
    if(Root1==Root2){
        return ;
    }
    if(S[Root2]>S[Root1]){
        S[Root1]+=S[Root2];
        S[Root2]=Root1;
    }else{
        S[Root2]+=S[Root1];
        S[Root1]=Root2;
    } 
}

用该方法构造的树高不超过 ⌊ log ⁡ 2 n ⌋ + 1 \lfloor \log_2n \rfloor +1 ⌊log2​n⌋+1。

Union操作优化后，Find操作的最坏时间复杂度为 O ( log ⁡ 2 n ) O(\log_2n) O(log2​n)。

Find操作的优化（压缩路径）

Find 操作，先找到根节点，再将查找路径上所有结点都挂到根结点下。

int Find(int S[],int x){
    int root=x;
    while(S[root]>=0)	root=S[root];
    while(x!=root){
        int t=S[x];
        S[x]=root;
        x=t;
    }
    return root;
}

每次 Find 操作，先找根，再 “压缩路径”，可使树的高度不超过 O ( α ( n ) ) O(\alpha (n)) O(α(n))。 α(n)是一个增长很缓慢的函数，对于常见的n值，通常α(n)≤4。

因此优化后并查集的Find、Union操作时间开销都很低。

408数据结构考研笔记——第五章树与二叉树（重点）
qq_52189899的博客
03-27 1万+
408数据结构考研笔记，笔记+课后习题，主用于个人学习整理，题目和图片源自王道课程，侵删
408——数据结构 第四章 树与二叉树
spercer97的博客
09-02 468
树与二叉树1. 树的基本概念2. 二叉树2.1 二叉树的定义及其主要特征2.2 二叉树的顺序存储结构和链式存储结构2.3 二叉树的遍历2.3.1 先序遍历：根左右（NLR）2.3.2 中序遍历：左根右（LNR）2.3.3 后序遍历：左右根（LRN）2.3.4 层序遍历2.4 线索二叉树的基本概念和构造3. 树、森林3.1 树的存储结构3.2 森林与二叉树的转换3.3 树和森林的遍历3.3.1 树的遍历3.3.2 森林的遍历4. 树与二叉树的应用4.1 二叉搜索树4.2 平衡二叉树4.3 哈夫曼(Huffma
408-数据结构-树（二）
不知道是谁的博客
04-02 708
考研小伙的数据结构笔记（二） 有错误的地方欢迎留言指出 按照王道数据结构的章节目录，本篇文章有以下一章 树与二叉树 树与二叉树 一些术语，记根节点为 R 前驱节点和后继节点：分别表示父节点和子节点 层数：根节点为第一层，层次往下递增 树的高度：树中结点的最大层数，树能够到的最底层 结点的高度：从叶节点开始向上逐层累加 结点的深...
408 知识点笔记——数据结构（栈和队列、树）
Aries_young的博客
05-22 3155
数据结构1 绪论2 线性表 1 绪论 【习题】 【解析】C、B 【习题】 【解析】A 【习题】 【解析】A 【习题】 【解析】C，有序表指出了表中数据时根据一定逻辑结构顺序排列的，值一种逻辑结构 【习题】 【解析】 2 线性表 【习题】 【解析】 数组和单链表的处理是一样的，这里给出 LeetCode 21 - 合并两个有序链表 迭代的解法，时间复杂度是 O(m+n)O(m+n)O(m+n)，空间复杂度是 O(1)O(1)O(1) /** * Definition for singly-li
挑战408——数据结构（16）——树的概念
redAnt的博客
11-01 624
从这一篇开始，进入一种新的数据结构，称为树。其实在学习树之前我们就接触过这个结构。 树的概念 现在我们从一幅图中来了解一下什么是树状结构： 这幅图主要说明cart这个单词的所有可能的组合结构，按照常理，我们先考虑三个字母的排列，然后由三个字母的排列中再进行拆分，最后重复拆分直到仅有一个字母。这个套路是不是很像我们之前学过的devide —— conquer算法？对的，这是一个递归的过程，也是计算...
数据结构第五章 树与二叉树
最新发布
05-30
第五章“树与二叉树”是数据结构中的重要组成部分，它主要涉及了树的定义、分类、性质以及在计算机科学中的应用。 首先，树的概念起源于图论，它是一种非线性的数据结构，与现实生活中的树相似，具有层次分明的结构...
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
本文主要梳理了树与二叉树的相关知识点，并包含了相关作业习题的详解。 首先，树被定义为一个有限集合，其中包含一个特殊的根节点以及可能的子树集合。每个子树本身也是一个树，这种定义具有递归性。在树的结构中，...
第五章 树与二叉树.ppt
12-05
【第五章 树与二叉树】 在计算机科学中，树是一种非常重要的数据结构，它模拟了现实世界中许多层次关系。本章主要探讨树和二叉树的相关概念，包括它们的定义、特性以及操作方法。 首先，我们来了解树的基本概念。...
第五章 树与二叉树.docx
01-10
本章主要讨论了树与二叉树的相关概念、性质、存储结构以及遍历方法。 首先，树的定义是：一棵非空的有限集合，其中的元素称为结点，且具有以下特性：有一个特殊的结点，称为根结点，其余结点可分为m（m>=0）个互不...
【408数据结构】树（一）
For Infinite
02-26 1280
树主要是应用题偏多。（算法题只考过了两次，都挺简单的，就是一个遍历；算法题在下一篇） 思维导图 基本概念 养成习惯：区分度和度之和： 结点个数=总度+1 度：指一棵树中，每一个结点度的最大值 链式 链式存储如果考多叉树，只有可能是孩子表示法那一块。 因此，大题只可能是二叉树那块。 遍历 递归遍历很简单。 void preOrder(Node *p) { if(p!=NULL) { visit(p); preOrder(p->lchild); preOrder(p->rc.
树与二叉树【考研/408】
imomoe的博客
08-28 631
树 有序树的左右子树顺序固定 结点数=所有结点的度+1 度为m的树（m叉树）中第i层上至多有m????−1个结点i≥1 高度为h的m叉树至多有(????h−1)/(m−1)个结点 具有n个结点的m叉树的最小高度为logm(????(????−1)+1） 总结点个数=总度数+1=0度的结点的个数+1度的结点的个数+……+n度的结点的个数 树的路径长度是指树根到每个节点的路径长的总和 满二叉树 第i个结点的双亲为i/2，左孩子为2i，右孩子为2i+1 边数=除了叶子结点之
408数据结构学习笔记——树、二叉树
JiangNan_1002的博客
03-30 2234
1.树的基本概念 2.树的性质 3.二叉树 4.二叉树的存储结构 5.王道课后题
408 DataStructure_Algorithm - 5.3 二叉树的遍历和线索二叉树
vast668的博客
12-12 218
二叉树的遍历&线索二叉树
挑战408——数据结构（23）——树与图
redAnt的博客
11-17 885
我们先回顾一下之前介绍的树的概念，在树的定义中，每个节点只能有一个父类，并且树中不能出现有环形。但是你可曾想过，当一棵树没有任何规则的时候，会发生什么吗？ 图的简介 现在，我们给图（graph）下一个定义： 图，是一种用节点和边来表示相互关系的数学模型。（A graph is a mathematical structure for representing relationships using...
408数据结构-树与森林 自学知识点整理
Engels_Si_Fish的博客
05-06 1007
25考研知识点个人向总结。
数据结构笔记——树、图（王道408）
亦梦亦醒乐逍遥的博客
10-26 1764
思维导图+精炼的个人思考
练习(tree)
weixin_40805072的博客
08-24 8816
一、一棵高度为h的满m叉树有如下性质：根结点所在层次为第1层，第h层上的结点都是叶结点，其余各层上的每个结点都有m棵非空子树，若按层次自顶向下，同一层自左向右，顺序从1开始对全部结点进行编号。 （1）各层的结点个数为多少 答:第一层有m^=1个，第二层有m^1个结点，第三层有m^2个结点.....一般的，第i层有m^i个 （2）编号为i的结点的双亲结点（若存在）的编号为多少 答：在m叉树的...
c/c++数据结构线索二叉树(408)
qq_46264842的博客
08-14 592
线索二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值