并查集和哈夫曼树

已于 2023-09-05 09:01:48 修改
阅读量96 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2023-08-30 08:45:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z5433523/article/details/132574569
版权

1.并查集

1.1需求分析

假设现在有这样一个需求，如下图的每一个点代表一个村庄，每一条线就代表一条路，所以有些村庄之间有连接的路，有
些村庄没有连接的路，但是有间接连接的路，根据上面的条件，能设计出一个数据结构，能快速执行下面2个操作：

  • 查询两个村庄之间是否有连接的路
  • 连接两个村庄
    在这里插入图片描述
    如何判断图中两点是否有连接
    在这里插入图片描述

1.2并查集概念

并查集（英文：Disjoint-set data structure，直译为不交集数据结构）是一种数据结构，用于处理一些不交集（Disjoint sets，一系列没有重复元素的集合）的合并及查询问题。并查集支持如下操作：

  • 查询（Find）：查询某个元素属于哪个集合，通常是返回集合内的一个“代表元素”。这个操作是为了判断两个元素是 否在同一个集合之中。
  • 合并（Union）：将两个集合合并为一个。
  • 添加：添加一个新集合，其中有一个新元素。添加操作不如查询和合并操作重要，常常被忽略。
    由于支持查询和合并这两种操作，并查集在英文中也被称为联合-查找数据结构（Union-find data structure）或者
    合并-查找集合（Merge-find set）。

1.3并查集算法介绍

  • 并查集有两种常见实现思路
  • a.Quick Find
  • 查找效率：O(1)
  • 合并效率：O(N)
  • b.Quick Union
  • 查找效率：O（logN）
  • 合并效率：O（logN）

1.3.1QuickFind的思路

  • 核心是将所有元素进行ID分组管理，每个元素对应一个ID号
  • find的时候，只需要返回这个元素对应的分组ID
  • 合并的时候Union(a,b)时候，将是属于a分组的元素，都改为b分组的ID号

1.3.2QuickUnion的思路

  • 将集合分为根结点和父节点的思想，所有节点保存他的父节点信息，当发现某个节点的父节点就是他自己的时候，这个节点就是根结点
  • find操作就是找到这个元素的根结点，判断两个元素的根结点是不是一致，来判断是否连通。
  • 合并操作的时候，Union(a, b)的时候，不是合并a和b，而是将a的根结点和b的根节点进行合并

1.3.3基于size的算法改进

  • 在Union过程中，可能会出现不平衡的情况，甚至退化成为链表，Union(1,3)

在这里插入图片描述

  • 将元素少的树，嫁接到元素多的树

1.3.4 基于rank的算法改进

在这里插入图片描述

  • 矮的树，嫁接到高的树

#ifndef DATA_STRUCTURE_BASE_H
#define DATA_STRUCTURE_BASE_H
typedef int Element;
#endif //DATA_STRUCTURE_BASE_H



#ifndef DATA_STRUCTURE_QUICKFINDSET_H
#define DATA_STRUCTURE_QUICKFINDSET_H
#include "base.h"
/* 并查集的QuickFind算法下的结构定义
 * 每一个元素都存有一个编号，只要编号一样，就代表一个集团的人
 * 合并时，就是把另外一个团队的人的老大改为这个团队的老大
 * */
typedef struct{
    Element *data;				// 存放的具体数据，利用索引来建立数据的关系
    int n;						// 并查集的元素个数
    int *groupID;				// 每个元素的编号
}QuickFindSet;
//产生n个元素的并查集
QuickFindSet *createQuickFindSet(int n);
//释放并查集
void releaseQuickFindSet(QuickFindSet *setQF);
// 初始化并查集，设置元素值和对应的编号
void initQuickFindSet(QuickFindSet *setQF, const Element *data, int n);
// 查：判断两个元素是不是同一个组ID
int isSameQF(QuickFindSet *setQF, Element a, Element b);
// 并：合并两个元素
void unionQF(QuickFindSet *setQF, Element a, Element b);
#endif //DATA_STRUCTURE_QUICKFINDSET_H



#include "quickFindSet.h"
#include<iostream>
//产生n个元素的并查集
QuickFindSet *createQuickFindSet(int n){
    QuickFindSet* setQF=new QuickFindSet ;
    setQF->data=new Element[n] ;
    setQF->groupID=new int[n];
    setQF->n=n;
    return setQF;
}
//释放并查集
void releaseQuickFindSet(QuickFindSet *setQF){
    if(setQF){
        if(setQF->groupID){
            delete setQF->groupID;
        }
        if(setQF->data){
            delete setQF->data;
        }
        delete setQF;
    }
}
// 初始化并查集，设置元素值和对应的编号
void initQuickFindSet(QuickFindSet *setQF, const Element *data, int n){
    for(int i=0;i<n;i++){
        setQF->data[i]=data[i];     //元素赋值
        setQF->groupID[i]=i;        //第i个元素的组ID就是i，自己管理自己
    }
}
static int findIndex(QuickFindSet *setQF, Element a){
    for(int i=0;i<setQF->n;i++){
        if(setQF->data[i]==a){
            return i;
        }
    }
    return -1;
}
// 查：判断两个元素是不是同一个组ID
int isSameQF(QuickFindSet *setQF, Element a, Element b){
    // 把元素转换为并查集中对应的索引号
    int aIndex= findIndex(setQF,a);
    int bIndex= findIndex(setQF,b);
    if(aIndex==-1||bIndex==-1){         // 并查集中没有a或b，返回假
        return 0;
    }
    return aIndex==bIndex;
}
// 并：合并两个元素
void unionQF(QuickFindSet *setQF, Element a, Element b){
    int aIndex= findIndex(setQF,a);
    int bIndex= findIndex(setQF,b);
    int bGrapId=setQF->groupID[bIndex];         // 备份b的老大，后面就判断所有元素是不是老大是b
    for(int i=0;i<setQF->n;i++){
        if(setQF->groupID[i]==bGrapId){
            setQF->groupID[i]=setQF->groupID[aIndex];   // b的组ID，替换成a的组ID
        }
    }
}



#ifndef DATA_STRUCTURE_QUICKUNIONSET_H
#define DATA_STRUCTURE_QUICKUNIONSET_H
/* QuickUnion方法
 * 每个元素只保存他的父元素的编号，通过不断找父元素，最终找到根编号
 * find : 两个元素的根一样
 * union : a元素的根 和 b元素的根 进行合并
 * */
#include "base.h"

typedef struct {
    Element *data;
    int n;
    int *parent;			// 每个元素只知道他的父节点，通过父节点不断去找根节点
    int *size;				// 根节点位置存放这个集合的个数
}QuickUnionSet;
//产生n个元素的并查集
QuickUnionSet *createQuickUnionSet(int n);
//释放并查集
void releaseQuickUnionSet(QuickUnionSet *setQU);
//初始化并查集
void initQuickUnionSet(QuickUnionSet *setQU, const Element *data, int n);
// 查：判断两个元素是不是同一个组ID
int isSameQU(QuickUnionSet *setQU, Element a, Element b);
// 并：合并两个元素
void unionQU(QuickUnionSet *setQU, Element a, Element b);
#endif //DATA_STRUCTURE_QUICKUNIONSET_H



#include "quickUnionSet.h"
#include<iostream>
//产生n个元素的并查集
QuickUnionSet *createQuickUnionSet(int n){
    QuickUnionSet *setQU=new QuickUnionSet ;
    setQU->data=new Element[n];
    setQU->parent=new int[n];
    setQU->size=new int[n];
    setQU->n=n;
    return setQU;
}
//释放并查集
void releaseQuickUnionSet(QuickUnionSet *setQU){
    if(setQU){
        if(setQU->size){
            delete setQU->size;
        }
        if(setQU->parent){
            delete setQU->parent;
        }
        if(setQU->data){
            delete setQU->data;
        }
        delete setQU;
    }
}
//初始化并查集
void initQuickUnionSet(QuickUnionSet *setQU, const Element *data, int n){
    for(int i=0;i<setQU->n;i++){
        setQU->data[i]=data[i];
        setQU->parent[i]=i;
        setQU->size[i]=1;
    }
}
static int findIndex(QuickUnionSet *setQF, Element a){
    for(int i=0;i<setQF->n;i++){
        if(setQF->data[i]==a){
            return i;
        }
    }
    return -1;
}
static int findRootIndex(QuickUnionSet *setQU, Element a){
    // 找e的父亲，再找这个父亲的父亲，直到发现父亲的父亲是自己，那就是根了
    int curIndex= findIndex(setQU,a);       // 如果为-1 补
    // 向上遍历
    while(setQU->parent[curIndex]!=curIndex){
        curIndex = setQU->parent[curIndex];			// 将父节点ID作为下一个寻找的ID号
    }
    return curIndex;
}
// 查：判断两个元素是不是同一个组ID
int isSameQU(QuickUnionSet *setQU, Element a, Element b){
    // a和b的根节点
    int aRoot = findRootIndex(setQU, a);
    int bRoot = findRootIndex(setQU, b);
    if (aRoot == -1 || bRoot == -1) {
        return 0;
    }
    return aRoot == bRoot;
}
/* 在QuickUnion集合中，将a元素和b元素合并
 * 1. 找到a和b的根节点
 * 2. 将b的父节点指向a的索引
 * 根据size做优化，谁的元素多，就让另一根接入元素多的根
 * */
// 并：合并两个元素
void unionQU(QuickUnionSet *setQU, Element a, Element b){
    int aRoot = findRootIndex(setQU, a);
    int bRoot = findRootIndex(setQU, b);
    if (aRoot == -1 || bRoot == -1) {
        return;
    }
    if(aRoot!=bRoot){
        // 根据根节点元素个数来决定合并顺序
        int aSize=setQU->size[aRoot];
        int bSize=setQU->size[bRoot];
        if(aSize>bSize){
            setQU->parent[bRoot]=aRoot;
            setQU->size[aRoot]+=bSize;
        }else{
            setQU->parent[aRoot]=bRoot;
            setQU->size[bRoot]+=aSize;
        }
    }
}


#include <stdio.h>
#include "quickFindSet.h"
#include "quickUnionSet.h"
// QuickFind的测试
int test01() {
    int n = 9;
    QuickFindSet *QFSet = createQuickFindSet(n);
    Element data[9];
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); ++i) {
        data[i] = i;
    }
    initQuickFindSet(QFSet, data, n);

    unionQF(QFSet, 3, 4);
    unionQF(QFSet, 8, 0);
    unionQF(QFSet, 2, 3);
    unionQF(QFSet, 5, 6);
    if (isSameQF(QFSet, 0, 2)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    if (isSameQF(QFSet, 2, 4)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    unionQF(QFSet, 5, 1);
    unionQF(QFSet, 7, 3);
    unionQF(QFSet, 1, 6);
    unionQF(QFSet, 4, 8);
    if (isSameQF(QFSet, 0, 2)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    if (isSameQF(QFSet, 2, 4)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    releaseQuickFindSet(QFSet);
    return 0;
}

int test02() {
    int n = 9;
    QuickUnionSet *QUSet = createQuickUnionSet(n);
    Element data[9];
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); ++i) {
        data[i] = i;
    }
    initQuickUnionSet(QUSet, data, n);

    unionQU(QUSet, 3, 4);
    unionQU(QUSet, 8, 0);
    unionQU(QUSet, 2, 3);
    unionQU(QUSet, 5, 6);
    if (isSameQU(QUSet, 0, 2)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    if (isSameQU(QUSet, 2, 4)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    unionQU(QUSet, 5, 1);
    unionQU(QUSet, 7, 3);
    unionQU(QUSet, 1, 6);
    unionQU(QUSet, 4, 8);
    if (isSameQU(QUSet, 0, 2)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    if (isSameQU(QUSet, 2, 4)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }
    // releaseQuickFindSet(QFSet);
    return 0;
}

int main() {
    test01();
    return 0;
}

1.3.5 路径压缩

  • 在find时使路径上的所有节点都指向根节点，从而降低树的高度
  • 指向父节点的父节点
  • 都指向根结点

2. 哈夫曼树

2.1 哈夫曼树相关的几个名词

  • 路径

在一棵树中，一个结点到另一个结点之间的通路，称为路径。
从根结点到结点 a 之间的通路就是一条路径。

  • 路径长度

在一条路径中，每经过一个结点，路径长度都要加 1 。
例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。
从根结点到结点 c 的路径长度为 3。

  • 节点的权

给每一个结点赋予一个新的数值，被称为这个结点的权。
例如，结点 a 的权为 7，结点 b 的权为 5。

  • 节点的带权路径长度

指的是从根结点到该结点之间的路径长度与该结点的权的乘积。
例如，结点 b 的带权路径长度为 2 * 5 = 10 。

树的带权路径长度为树中所有叶子结点的带权路径长度之和。通常记作 “WPL” 。
例如图中所示的这颗树的带权路径长度为：

WPL = 7 * 1 + 5 * 2 + 2 * 3 + 4 * 3
在这里插入图片描述

2.2 什么是哈夫曼树

当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称
这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。

2.3 构建哈夫曼树

  • 对于给定的有各自权值的 n 个结点，构建哈夫曼树有一个行之有效的办法：
  • 1.在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权
    值的和；
    1. 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
  • 3.重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。
    在这里插入图片描述
Z5433523
关注
专栏目录
AVL树/B树/红黑树/二叉搜索树/并查集/哈夫曼树/字典树实现合集（C++）
05-25
本文将深入探讨几种重要的数据结构，包括AVL树、B树、红黑树、二叉搜索树、并查集、哈夫曼树和字典树，并概述它们的实现原理和应用场景。 首先，我们来看**AVL树**，它是一种自平衡的二叉搜索树。在AVL树中，任意...
这是基本数据结构及其算法的C++实现，涉及单链表、双链表、栈 、二叉树、并查集、哈夫曼树、平衡二叉树、二叉搜索树等.zip
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
哈夫曼树与并查集
qq_46440190的博客
07-19 390
哈夫曼树 并查集
408-数据结构-树的应用-哈夫曼树&并查集
qq_49400568的博客
07-19 739
哈夫曼树 哈夫曼实际上用于编码，使得编码长度达到最小，因为每一个字符在出现的概率上会有差异，针对出现概率大的用短的编码，出现概率小的用长编码，可以使得编码长度达到最小。编码过程使用二叉树实现。 带权路径总和最小即为哈夫曼树。 带权路径：每一个叶子结点有一个权值，以叶子结点到根结点需要走过的路经长度✖️权值。 如果权重值为字符出现的概率值，那么带权路径总和即为平均编码长度。 算法过程： 以每一个字符出现的概率作为权重值，产生叶子结点。 从小到大排序，取前两个分别为左子树和右子树形成新结点，他们两个权重相加为
408【数据结构】哈夫曼树、哈夫曼编码与并查集知识点与部分错题
weixin_44644443的博客
05-21 1903
总结与反思
第五章 树和二叉树（下）【哈夫曼树、并查集】
zdlzf的博客
11-18 218
结点的权:有某种现实含义的数值(如:表示结点的重要性等)结点的带权路径长度：从树的根到该结点的路径长度(经过的边数)与该结点上权值的乘积。树的带权路径长度:树中所有叶结点的带权路径长度之和 (WPL,Weighted Path Length)。在含有n个带权叶结点的二叉树中，其中带权路径长度(WPL) 最小的二叉树，也称最优二叉树。
数据结构复习指导之树与二叉树的应用（哈夫曼和并查集）
心碎烤肠的博客
05-13 1179
本章内容多以选择题或综合题的形式考查，但统考也会出涉及树遍历相关的算法题。树和二叉树的性质、遍历操作、转换、存储结构和操作特性等，满二叉树、完全二叉树、线索二叉树、哈夫曼树的定义和性质，都是选择题必然会涉及的内容。
408数据结构学习笔记——树与二叉树的应用——哈夫曼树和哈夫曼编码、并查集
JiangNan_1002的博客
04-07 2272
1.哈夫曼树和哈夫曼编码 2.并查集
详解哈夫曼树和哈夫曼编码
qq_45929428的博客
04-25 8601
哈哈夫曼树一、初始化函数init()二、合并操作unite()三、查询树根函数find()四、改进后的合并操作unite()五、改进后的find()六、判断是否属于同一集合same()并查集的复杂度并查集的实现代码 哈夫曼树 并查集是一种用来管理元素分组情况的数据结构，可以高效地进行查询、合并操作，但无法进行分割操作。 1.查询元素a和元素b是否属于同一组 2.合并元素a和元素b所在的组 并查集使用树形结构实现，但不是二叉树。 在并查集中，无需关注元素的兄弟、父亲是谁或树的结构如何，只需要关注元.
数据结构学习笔记04树(堆 哈夫曼树 并查集)
weixin_30345577的博客
04-04 191
一.堆(heap) 优先队列（Priority Queue）：特殊的“队列”，取出元素的顺序是依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。 数组 : 插入 — 元素总是插入尾部 ~ O ( 1 ) 删除 — 查找最大（或最小）关键字 ~ O ( n ) 从数组中删去需要移动元素 ~ O( n ) 链表: 插入 — 元素总是插入链表的头部 ~ O ( 1...
数据结构历年考研真题对应知识点（哈夫曼树和哈夫曼编码）
心碎烤肠的博客
07-14 1315
在介绍哈夫曼树之前，先介绍几个相关的概念: 从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径。 路径上的分支数目称为路径长度。 在许多应用中，树中结点常常被赋予一个表示某种意义的数值，称为该结点的权。 从树的根到一个结点的路径长度与该结点上权值的乘积，称为该结点的带权路径长度。 树中所有叶结点的带权路径长度之和称为该树的带权路径长度，记为
ACM必备：高级数据结构详解——字典树、并查集与哈夫曼树
本文主要介绍三种重要的高级数据结构：字典树（Trie）、并查集（Union-Find Sets）和哈夫曼树（Huffman Tree）。 1. **字典树（Trie）** Trie，又称前缀树，是一种特殊的数据结构，用于高效地存储和查找具有公共...
通用型函数——冒泡排序
2401_84654619的博客
10-29 376
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
栈和队列（数据结构）
etamaos的博客
10-28 322
1.创建新队列（结点；
java-数据结构
2301_80708315的博客
10-30 977
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 534
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
最新发布
nick_912912的博客
11-02 172
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
数据结构初识及顺序表详解
chuxinweihui的博客
11-01 853
我们在写程序的时候，会出现许多的数据，如果我们想要修改某一个值或者删除和添加一个数据的时候就会非常困难，尤其是数据量庞大的时候，这时候数据结构就出来了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值