数据结构 学习笔记（六）：树（下）：堆，哈夫曼树和哈夫曼编码，集合及运算

最新推荐文章于 2022-09-20 20:33:27 发布
最新推荐文章于 2022-09-20 20:33:27 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 2. 数据结构 数据结构 文章标签： 数据结构 二叉树 哈夫曼树 哈夫曼编码 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jurbo/article/details/74891400
版权

请跟着上一讲 数据结构 学习笔记（五）：树（中）：二叉搜索树，平衡二叉树 继续学习

5.1 堆

5.1.1 什么是堆

优先队列：特殊的“队列”，取出元素的顺序是依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。

优先队列的完全二叉树表示：

这里写图片描述

堆的两个特性

结构性：用数组表示的完全二叉树
有序性：任一结点的关键字是其子树所有结点的最大值（或最小值）
最大堆（也称为大顶堆）：最大值
最小堆（也称小顶堆）：最小值

最大堆最小堆的例子：

这里写图片描述

堆的抽象数据类型描述：

这里写图片描述

5.1.2 堆的插入

最大堆的插入：

算法：将新增结点插入到从其父结点到根结点的有序序列中。

bool Insert( MaxHeap H, ElementType X )
{ /* 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵 */
    int i;

    if ( IsFull(H) ) { 
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */
    for ( ; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; /* 上滤X */
    H->Data[i] = X; /* 将X插入 */
    return true;
}

5.1.3 堆的删除

最大堆的删除。

算法：取出根结点（最大值）的元素，同时删除堆的一个结点。

ElementType DeleteMax( MaxHeap H )
{ /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */
    int Parent, Child;
    ElementType MaxItem, X;

    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }

    MaxItem = H->Data[1]; /* 取出根结点存放的最大值 */
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 */
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;

    return MaxItem;
}

5.1.4 堆的建立

最大堆的建立。

堆从下标为1的地方开始放。

建立最大堆：将已经存在的N个元素按最大堆的要求存放在一个一维数组中。

方法1：通过插入操作，将N个元素一个个相继插入到一个初始为空的堆中区。
方法2：在线性时间复杂度下建立最大堆

  1. 将N个元素按输入顺序存入，先满足完全二叉树的结构特性
  2. 调整各个结点的位置，以满足最大堆的有序特性
typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */

#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */

MaxHeap CreateHeap( int MaxSize )
{ /* 创建容量为MaxSize的空的最大堆 */

    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/

    return H;
}

/*----------- 建造最大堆 -----------*/
void PercDown( MaxHeap H, int p )
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;

    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}

void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */

    int i;

    /* 从最后一个结点的父节点开始，到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

C语言实现：堆的定义与操作

typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */

#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */

MaxHeap CreateHeap( int MaxSize )
{ /* 创建容量为MaxSize的空的最大堆 */

    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/

    return H;
}

bool IsFull( MaxHeap H )
{
    return (H->Size == H->Capacity);
}

bool Insert( MaxHeap H, ElementType X )
{ /* 将元素X插入最大堆H，其中H->Data[0]已经定义为哨兵 */
    int i;

    if ( IsFull(H) ) { 
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */
    for ( ; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; /* 上滤X */
    H->Data[i] = X; /* 将X插入 */
    return true;
}

#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */

bool IsEmpty( MaxHeap H )
{
    return (H->Size == 0);
}

ElementType DeleteMax( MaxHeap H )
{ /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */
    int Parent, Child;
    ElementType MaxItem, X;

    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }

    MaxItem = H->Data[1]; /* 取出根结点存放的最大值 */
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 */
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;

    return MaxItem;
} 

/*----------- 建造最大堆 -----------*/
void PercDown( MaxHeap H, int p )
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;

    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}

void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */

    int i;

    /* 从最后一个结点的父节点开始，到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

5.2 哈夫曼树和哈夫曼编码

5.2.1 什么是哈夫曼树

例子：

这里写图片描述

这里写图片描述

这里写图片描述

哈夫曼树的定义

带权路径长度（WPL）：

这里写图片描述

最优二叉树或哈夫曼树：WPL最小的二叉树。

5.2.2 哈夫曼树的构造

每次把权值最小的两棵二叉树合并。

typedef struct TreeNode *HuffmanTree;
struct TreeNode
{
    int Weight;
    HuffmanTree Left,Right;
}
HuffmanTree Huffman(MinHeap H)
{
    //假设H->Size个权值已经存在H->Elements[]->Weight里
    int i;
    HuffmanTree T;
    BuildMinHeap(H) //将H->Elements[]按权值调整为最小堆
    // 做H->Size -1次合并
    for(i=1;i<H->Size;i++)
    {
        T=malloc(sizeof(struct TreeNode)); //建立新结点
        //从最小堆中删除一个结点，作为新T的左子结点
        T->Left=DeleteMin(H);
        //从最小堆中删除一个结点，作为新T的右子节点
        T->Right=DeleteMin(H);
        //计算新权值
        T->Weight=T->Left->Weight+ T->Right->Weight;
        //将新T插入最小堆
        Insert(H,T);
    }
}

哈夫曼树的特点：

这里写图片描述

5.2.3 哈夫曼编码

这里写图片描述

二叉树用于编码：

这里写图片描述

哈夫曼编码的例子

这里写图片描述

5.3 集合及运算

5.3.1 集合的表示及查找

集合运算：交、并、补、差、判定一个元素是否属于某一集合

并查集：集合并、查某元素属于什么集合

并查集问题中集合存储如何实现？（可以用树结构表示集合，树的每个结点代表一个集合元素）

采用数组存储形式

这里写图片描述

集合运算

（1）查找某个元素所在的集合（用根结点表示）

int Find(SetType S[],ElementType X)
{
    //在数组S中查找值为X的元素所属的集合
    int i;
    for(i=0;i<MAXSIZE && S[i].Data!=X;i++);
    if(i>=MaxSize)
        return -1; //未找到X
    for(;S[i].Parent>=0;i=S[i].Parent);
        return i;  //找到X所属集合，返回树根结点在数组S中的下表
}

（2）集合的并运算

  • 分别找到 X1 和 X2 两个元素所在集合树的根结点
  • 如果他们不同根，则将其中一个跟结点的父结点指针设置成另一个根结点的数组下表
void Union(SetType S[],ElementType X1,ElementType X2)
{
    int Root1,Root2;
    Root1=Find(S,X1);
    Root2=Find(S,X2);
    if(Root1!=Root2) //当X1和X2不属于同一个子集时，才需要合并
        S[Root2].Parent=Roo1;
}

5.3.2 集合的并运算

C语言实现：集合的操作

#define MAXN 1000                  /* 集合最大元素个数 */
typedef int ElementType;           /* 默认元素可以用非负整数表示 */
typedef int SetName;               /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MAXN]; /* 假设集合元素下标从0开始 */

void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}

SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}
Jurbo
关注
专栏目录
数据结构与算法_哈夫曼树&堆
刘同学的博客
07-07 601
1. 哈夫曼树----最优二叉树 定义： 带权路径长度最短的树（将最常用的数据放在离根节点近的地方） 如果用树来保存数据，数据本身有一个出现的权重，那么把出现权重大的值放在离根节点近的地方 带权路径长度（WPL)计算方式请见附图 哈夫曼树示意图请见附图 2. 堆----最大（小）堆 实际上就是最大（小）的完全二叉树 最大堆： 是一个完全二叉树 堆中的任意一个节点的值都大于或者等于左右子树中值...
数据结构学习笔记（5.树与二叉树 6.图）
super_song的博客
05-22 876
文章目录第五章 树与二叉树树树的常考性质 第五章 树与二叉树 树 树的基本概念 空树，非空树 非空树特性 树的基本概念 数学描述 子树，子树之间互不相交 树是一种递归定义的结构，任何一个树都可以看做是由根节点和若干个不相交的子树所组成的 树形逻辑结构的应用 结点之间的关系描述 祖先结点：从一个节点出发一直往上走，直到根节点，所遇到的所有节点都是祖先结点 子孙结点：从一个节点出发，下面所有长出的节点都是他的子孙结点 双亲结点：一个结点的直接前驱，就是双亲结点，也叫父结点 孩子结点：一个结点的
树（堆、哈夫曼树、集合与运算）
Qingxingxx的博客
02-13 204
堆 typedef struct HNode *Heap; /* 堆的类型定义 */ struct HNode { ElementType *Data; /* 存储元素的数组 */ int Size; /* 堆中当前元素个数 */ int Capacity; /* 堆的最大容量 */ }; typedef Heap MaxHeap; /* 最大堆...
【堆 && 哈弗曼树】树-堆结构练习——合并果子之哈夫曼树
weixin_30314793的博客
12-28 169
堆排序的应用之哈夫曼树 1952年, David A. Huffman提出了一个不同的算法，这个算法可以为任何的可能性提供出一个理想的树。香农-范诺编码（Shanno-Fano）是从树的根节点到叶子节点所进行的的编码，哈夫曼编码算法却是从相反的方向，暨从叶子节点到根...
堆算哈夫曼树，王道
p13421436162的博客
03-21 166
#include<stdio.h> #include using namespace std; priority_queue<int,vector,greater> que; int main(){ int n; while(scanf("%d",&n) != EOF){ while(que.empty() == false) que.pop(); for(in...
哈夫曼树+二叉堆
Geek
08-07 1033
  哈夫曼树的介绍 Huffman Tree，中文名是哈夫曼树或霍夫曼树，它是最优二叉树。 定义：给定n个权值作为n个叶子结点，构造一棵二叉树，若树的带权路径长度达到最小，则这棵树被称为哈夫曼树。 这个定义里面涉及到了几个陌生的概念，下面就是一颗哈夫曼树，我们来看图解答。 (01) 路径和路径长度 定义：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。若规定...
数据结构笔记(C语言版)
去无人的岛，摸鲨鱼的角
09-20 5711
personal note
树-树及二叉树的定义和存储结构、遍历二叉树、线索二叉树、哈夫曼树及其应用（C语言描述）
ZZay's
08-16 622
树-树的定义及存储结构、二叉树、遍历二叉树、线索二叉树、哈夫曼树（C语言描述） 此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、树(Tree)的定义： 树(Tree)：是n(n>=0)个结点的有限集。n=0时称为空树。不同于先前所学的一对一的线性结构，树是一种一对多的数据结构。在任意一棵非空树中：(1)：有且仅有一个特定的称为根(Root)的结点。根结点是唯一的，不可能存在多个根结点；(2)：当n>1时，其余结
《2020王道》| 数据结构 | 学习笔记 | 第四章 | 树和二叉树
Wu Y H的博客
08-03 1227
《2020年王道数据结构》考研复习学习笔记重要知识点摘录，本来应该算是转载性质，因为我只是把重要知识点摘抄出来，并不是我自己的想法和经验，但是转载需要原文链接，王道官网并没有给出整本书的详细内容链接，所以暂且选择原创。我在这里申明该博客只用于个人学习记录
王道考研数据结构笔记
热门推荐
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
数据结构（C语言版）综合实践集合运算
04-01
题目： 7. 集合运算 (单循环链表) 1.问题描述： 设有两个带头结点的单循环链表存储的集合A、B，其元素类型为字符或者整形，且以非递减方式存储，其头结点分别为ha、hb。要求下面各问题中的结果集合同样以非递减方式存储，结果集合不影响原集合。 2.实现要求： ⑶ 编写集合元素测试函数IN_SET，如果元素已经在集合中返回0，否则返回1； ⑷ 编写集合元素输入并插入到单链表中的函数INSERT_SET，保证所输入的集合中的元素是唯一且以非递减方式存储在单循环链表中； ⑶ 编写求集合A、B的交C=A∩B的函数，并输出集合C的元素； ⑷ 编写求集合A、B的并D=A∪B的函数，并输出集合D的元素； ⑸ 求集合A与B的对称差E=(A-B)∪(B-A) 的函数，并输出集合D的元素； ⑹ 设计一个菜单，具有输入集合元素、求集合A、B的交C、求集合A、B的并D、求集合A与B的对称差E、退出等基本的功能。 3.测试数据：字符型和整形由同学们自定，但集合A、B的元素个数不得少于15个。
堆与哈夫曼树
m0_50710793的博客
11-29 814
一、堆 1、基本定义 堆是一棵完全二叉树，树中每一个结点的值都不小于（不大于）其左右孩子的值。 大顶堆：父亲结点的值大于等于孩子结点的值。 小顶堆：父亲结点的值小于等于孩子结点的值。 堆一般用于优先队列的实现，而优先队列一般使用大顶堆。 2、堆的操作 （1）堆的表示 const int maxn = 100; int heap[maxn], n = 100; （2）向下调整堆 在建立堆的过程中，总是将结点从上往下调整。 调整方法：总是将当前结点V与它的左右孩子比较（如果有的话），假如孩子中存在比结点V大的
哈夫曼树编解码
05-09 2398
哈夫曼树编解码 题目： 思路： 代码： #include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> using namespace std; typedef struct Node{ char data = '\0'...
堆（heap)与哈夫曼树（数据结构浙大mooc《树下》）
sxycylq的博客
10-10 456
堆（heap) 优先队列：特殊的队列，取出元素的顺序是按照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序 采用数组或链表实现优先队列 数组： 插入，元素总是插入尾部 O(1) 删除，查找最大（或最小）关键字O(n)，从数组中删去需要移动元素O(n) 链表 插入，元素总是插入链表的头部 O(1) 删除，查找最大（或最小）关键字O(n)，删去结点 O(1) 有序数组 插入，找到合适的位置O(n)或O(log2(n))，移动元素并插入 删除，删去最后一个元素O(1) 用二叉树进行存储 采用二
二叉树、BST、并查集、堆、哈夫曼树
Dai
08-04 283
 二叉树操作，二叉搜索树操作，先序层序等遍历，树的旋转，并查集，最大堆建立，插入，删除，堆排序、哈弗曼树WPL（带权路径和最大） 程序来源于“算法笔记”，复习的时候手写了一遍，基础还是很有用的，这些常用的记一记感觉确实做题的时候顺畅一些 #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;queue&gt; using na...
##数据结构##如何创建一棵哈夫曼树并实现堆
hei我在这
03-17 726
哈夫曼树是一种二叉树，但是它是一种加权路径长度最短的二叉树。其可用堆来实现它的构建其构建方法如下：//heap.h //仿函数 template&lt;class T&gt; struct Less { bool operator()(const T&amp; left, const T&amp; right)const { return left &lt; right; } }; ...
【基本算法】哈夫曼树和哈弗曼编码的C++实现及具体思路（附上哈夫曼树以及优先队列的相关详细知识点补充）
qq_38391210的博客
11-01 231
写在前面 这个学期在上算法课的课程，其实也是对本科算法课的扩展和延伸。很多算法以前虽然知道，但是理解不深，并且以前没有动手实践的意识，所以这个学期尽可能的实现每一种重要算法，并且把实现的过程和代码记录下来。 代码实现 #include<iostream> #include<queue> #include<vector> #include<map> #include<string> using namespace std; map<int,st
[数据结构与算法]Huffman树及其应用
德仔
10-16 2528
堆和哈夫曼树
leslie___的博客
05-06 834
堆什么是堆优先队列(Priority Queue)堆的抽象数据类型描述1.最大堆的创建2. 最大堆的插入3. 最大堆的删除最大堆的建立哈夫曼树与哈夫曼编码哈夫曼树的定义哈夫曼树的构造哈夫曼树的特点哈夫曼编码 什么是堆 优先队列(Priority Queue) 特殊的“队列”，取出元素的顺序依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序 采用数组实现优先队列 插入——元素总是插入...
树和二叉树数据结构详解：从基本术语到哈夫曼编码
"本资源是关于数据结构课程的第六章，主要讲解了树和二叉树...这个课件详细介绍了树和二叉树的基本概念、操作和应用，是学习数据结构和算法的重要参考资料。理解并掌握这些知识对于编程和解决复杂问题具有极大的帮助。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值