高级数据结构并查集详解

已于 2022-02-21 19:54:34 修改
阅读量305 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： java 数据结构
于 2022-02-20 16:59:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xylitolz/article/details/123032472
版权

文章目录

并查集(Union Find)

定义

孩子节点指向父亲节点的一种很不一样的树形结构，对于一组数据，主要支持两个动作：

  • u n i o n ( p , q ) union(p, q) union(p,q)：把元素 p p p和元素 q q q所在的两个不相交的集合合并为一个集合
  • i s C o n n e c t e d ( p , q ) isConnected(p,q) isConnected(p,q)：查询元素 p p p和元素 q q q是否在同一个集合中

基本的数据表示

在这里插入图片描述

0 / 1 0/1 0/1表示不同的集合，上图中元素 [ 0 , 2 , 4 , 6 , 8 ] [0,2,4,6,8] [0,2,4,6,8]属于同一个集合，元素 [ 1 , 3 , 5 , 7 , 9 ] [1,3,5,7,9] [1,3,5,7,9]的属于同一个集合

接口定义

/**
 * 并查集支持的操作
 */
public interface UF {
    boolean isConnected(int p, int q);
    void unionElements(int p, int q);
    int getSize();
}

版本一：Quick Find

初始化

public class UnionFind1 implements UF{
    private int[] id;                                       // 节点x的父节点是id[x]
    public UnionFind1(int size) {
        id = new int[size];

        for (int i = 0; i < id.length; i++) {
            id[i] = i;                                    // 此时 每个元素都所属不同的集合
        }
    }
    
    @Override
    public int getSize() {
        return id.length;
    }
}

isConnected

在这里插入图片描述

/**
  * 查找元素p所对应的集合编号
  * O(1)
  * @param p
  * @return
  */
private int find(int p) {
    if (p < 0 || p >= id.length) {
        throw new IllegalArgumentException("p is out of bound.");
    }
    return id[p];
}

/**
  * 元素p和元素q是否属于同一个集合
  * O(1)
  * @param p
  * @param q
  * @return
  */
@Override
public boolean isConnected(int p, int q) {
    return find(p)==find(q);
}

Union

在这里插入图片描述
可以将4所属集合中的元素都合并到1所属集合中，也可以将1所属集合中的元素都合并到2所属集合中：

在这里插入图片描述

/**
 * 合并元素pq所属的集合
 * O(n)
 * @param p
 * @param q
 */
@Override
public void unionElements(int p, int q) {
    int pId = find(p);
    int qId = find(q);

    if (pId == qId) {
        return ;
    }

    for (int i = 0; i < id.length; i++) {
        if (id[i] == pId) {
            id[i] = qId;
        }
    }
}

时间复杂度分析

Quick Find本质上属于用数组模拟并查集的操作

  • unionElements(p,q)​时间复杂度为 O ( n ) O(n) O(n)
  • isConnected(p,q)​时间复杂度为 O ( 1 ) O(1) O(1)

版本二：Quick Union

基本思想

将每一个元素，看做是一个节点，节点之间相连接形成树形结构，该树形结构中是孩子节点指向父亲节点：
在这里插入图片描述
上图的数据表示如下：
在这里插入图片描述

Quick Union下的数据表示

在这里插入图片描述
在这里插入图片描述
初始化时，相当于有10颗树

public class UnionFind2 implements UF{
    private int[] parent;

    public UnionFind2(int size) {
        parent = new int[size];

        for (int i = 0; i < size; i++) {
            parent[i] = i;                 // 初始化：每个节点指向本身，即每个节点都是一棵独立的树
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }
}

Union

U n i o n ( 4 , 3 ) Union(4,3) Union(4,3)：让4节点指向3节点，数组中表示即为parent[4]=3
在这里插入图片描述
在这里插入图片描述
U n i o n ( 3 , 8 ) Union(3,8) Union(3,8)：让3节点指向8节点，数组中表示即为parent[3]=8​

在这里插入图片描述
在这里插入图片描述
U n i o n ( 6 , 5 ) Union(6,5) Union(6,5)：让6节点指向5节点，数组中表示即为parent[6]=5
在这里插入图片描述
在这里插入图片描述
U n i o n ( 9 , 4 ) Union(9,4) Union(9,4)：让9节点指向4节点所在树的根节点，涉及查询操作，查询4所在树的根节点，如果让9直接指向4就形成了链表，体现不出树的优势，数组中表示即为parent[9]=8
在这里插入图片描述
在这里插入图片描述
U n i o n ( 6 , 2 ) Union(6,2) Union(6,2)：让6节点所在树的根节点指向2节点所在树的根节点
在这里插入图片描述

/**
 * 查找元素p所对应的集合编号
 * O(h)，h为树的高度
 * @param p
 * @return
 */
private int find(int p) {

    if (p < 0 || p >= parent.length) {
        throw new IllegalArgumentException("p is out of bound.");
    }

    while (p != parent[p]) {       // 寻找根节点
        p = parent[p];
    }
    return p;
}
/**
 * 合并元素pq所属的集合
 * O(h)，h为树的高度
 * @param p
 * @param q
 */
@Override
public void unionElements(int p, int q) {
    int pRoot = find(p);
    int qRoot = find(q);

    if (pRoot == qRoot) {
        return ;
    }

    parent[pRoot] = qRoot;
}

isConnected

/**
 * 元素p和元素q是否属于同一个集合
 * O(h)，h为树的高度
 * @param p
 * @param q
 * @return
 */
@Override
public boolean isConnected(int p, int q) {
    return find(p) == find(q);
}

时间复杂度分析

  • unionElements(p,q)和isConnected(p,q)的时间复杂度均为 O ( h ) O(h) O(h)， h h h为树的高度，通常树高远远小于数据总量 n n n

版本三：Quick Union基于size的优化

版本二中由于在合并两个树时不对两个树的形状做判断，因此有可能形成链表，例如下图经由 U n i o n ( 0 , 1 ) Union(0,1) Union(0,1)、 U n i o n ( 0 , 2 ) Union(0,2) Union(0,2)、 U n i o n ( 0 , 3 ) Union(0,3) Union(0,3)形成：
在这里插入图片描述
一个简单的解决方案是考虑树的节点数目size

在这里插入图片描述
例如上图考虑 U n i o n ( 9 , 4 ) Union(9,4) Union(9,4)，如果让8节点直接指向9，那么新的树高到达了4，但如果让9节点指向8，那么新的树高仍然为3

在这里插入图片描述
因此让节点数目少的那颗树的根节点指向节点数目多的那颗树的根节点，这样有更高的概率让形成的新树的高度比较低

/**
 * 优化第二版的unionElements方法
 * 基于size的优化
 */
public class UnionFind3 implements UF {
	private int[] parent;
	private int[] sz;         // sz[i]表示以i为根的集合中元素个数

	public UnionFind3(int size) {
		parent = new int[size];
		sz = new int[size];
		for (int i = 0; i < size; i++) {
			parent[i] = i;
			sz[i] = 1;
		}
	}

	@Override
	public int getSize() {
		return parent.length;
	}

	/**
	 * 查找元素p所对应的集合编号
	 * O(h)，h为树的高度
	 * @param p
	 * @return
	 */
	private int find(int p) {

		if (p < 0 || p >= parent.length) {
			throw new IllegalArgumentException("p is out of bound.");
		}

		while (p != parent[p]) {
			p = parent[p];
		}

		return p;
	}

	/**
	 * 元素p和元素q是否属于同一个集合
	 * O(h)
	 * @param p
	 * @param q
	 * @return
	 */
	@Override
	public boolean isConnected(int p, int q) {
		return find(p) == find(q);
	}

	/**
	 * 合并元素pq所属的集合
	 * O(h)
	 * @param p
	 * @param q
	 */
	@Override
	public void unionElements(int p, int q) {
		int pRoot = find(p);
		int qRoot = find(q);

		if (pRoot == qRoot) {
			return ;
		}

		/*
		 * 让元素个数比较少的根节点指向元素个数比较多的根节点
		 * 避免形成链表
		 */
		if (sz[pRoot] < sz[qRoot]) {
			parent[pRoot] = qRoot;   // pRoot指向qRoot
			sz[qRoot] += sz[pRoot];
		} else {
			parent[qRoot] = pRoot;
			sz[pRoot] += sz[qRoot];
		}
	}
}

版本四：Quick Union基于rank的优化

版本三的优化思路是在每次合并两颗树时，尽量保证形成的新树的高度不会增加
在这里插入图片描述
考虑对上图所示的并查集进行 U n i o n ( 4 , 2 ) Union(4,2) Union(4,2)操作，根据版本三的执行逻辑，应该是节点8指向节点7，但是明显树高增加了
在这里插入图片描述
所以更加合理的合并方案应该是让树高比较低的树的根节点指向树高比较高的根节点：
在这里插入图片描述
因此合并时应该让深度比较低的那颗树向深度比较高的那颗树合并，使用rank[i]记录根节点为i的树的高度

/**
 * 基于rank的优化
 */
public class UnionFind4 implements UF {
    private int[] parent;
    private int[] rank;         // rank[i]表示以i为根的集合所表示的树的层数

    public UnionFind4(int size) {
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    /**
		 * 查找元素p所对应的集合编号
		 * O(h)，h为树的高度
		 *
		 * @param p
		 * @return
		 */
    private int find(int p) {

        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of bound.");
        }

        while (p != parent[p]) {
            p = parent[p];
        }
        return p;
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    /**
		 * 元素p和元素q是否属于同一个集合
		 * O(h)
		 *
		 * @param p
		 * @param q
		 * @return
		 */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    /**
		 * 合并元素pq所属的集合
		 * O(h)
		 *
		 * @param p
		 * @param q
		 */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot) {
            return;
        }

        /*
		 * 根据两个元素所在树的rank不同判断合并方向
		 * 将rank低的集合合并到rank高的集合上
		 */
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;   // pRoot指向qRoot
        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;       
        }
    }
}

版本五：路径压缩Path Compression

在这里插入图片描述
对于如上的三棵树，虽然表示的是同一个集合，但是由于树高不同，因此执行find操作的效率也不同，最理想的情况当然是最下面那种树，树高为2，路径压缩就是在并查集中将高树压缩为矮树，路径压缩发生在执行find操作时，在查找根节点的过程中，顺便让树高降低：
在这里插入图片描述
parent[p]=parent[parent[p]]表示让p节点指向其父节点的父节点

例如查找4节点的父节点，那么执行完parent[p]=parent[parent[p]]后，4节点的父节点为2节点：
在这里插入图片描述
此时2节点仍然不是根节点，继续向上遍历：

在这里插入图片描述
至此就找到了4的根节点0，同时在查找的过程中将树的高度由5降为3，这个过程就叫做路径压缩。

在这里插入图片描述

/**
 * 路径压缩
 * 优化find方法
 */
public class UnionFind5 implements UF{
    private int[] parent;
    private int[] rank;         // rank[i]表示以i为根的集合所表示的树的层数
                                // 不反应高度/深度

    public UnionFind5(int size) {
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    /**
     * 查找元素p所对应的集合编号
     * O(h)，h为树的高度
     * @param p
     * @return
     */
    private int find(int p) {

        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of bound.");
        }

        while (p != parent[p]) {
            // 相对于版本四，仅增加如下一行代码
            parent[p] = parent[parent[p]];      // 路径压缩 
            p = parent[p];                      // 继续查找根节点
        }
        return p;
    }

    /**
     * 元素p和元素q是否属于同一个集合
     * O(h)
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    /**
     * 合并元素pq所属的集合
     * O(h)
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot) {
            return ;
        }

        /*
         * 根据两个元素所在树的rank不同判断合并方向
         * 将rank低的集合合并到rank高的集合上
         * 并不实际反应节点的深度/高度值
         */
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;   // pRoot指向qRoot

        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}

版本六：利用递归优化路径压缩

在上一版本中，利用路径压缩将下图中左边的树压缩成右边的形状，性能已经有了较大提升
在这里插入图片描述
但是在最理想的情况下， 希望将上图左边的树直接压缩成高度为2的树：
在这里插入图片描述
这样一种路径压缩可以利用递归来实现，在查找4的根节点过程中，将4以及之前的节点全部指向根节点。

/**
 * 路径压缩
 * 利用递归 优化find方法
 */
public class UnionFind6 implements UF{
    private int[] parent;
    private int[] rank;         // rank[i]表示以i为根的集合所表示的树的层数
                                // 不反应高度/深度

    public UnionFind6(int size) {
        parent = new int[size];
        rank = new int[size];
        for (int i = 0; i < size; i++) {
            parent[i] = i;
            rank[i] = 1;
        }
    }

    @Override
    public int getSize() {
        return parent.length;
    }

    /**
     * 查找元素p所对应的集合编号
     * O(h)，h为树的高度
     * @param p
     * @return 根节点
     */
    private int find(int p) {

        if (p < 0 || p >= parent.length) {
            throw new IllegalArgumentException("p is out of bound.");
        }
		
        // p 节点以及p节点之前的节点都将指向根节点
        if (p != parent[p]) {
            parent[p] = find(parent[p]);
        }
        return parent[p];
    }

    /**
     * 元素p和元素q是否属于同一个集合
     * O(h)
     * @param p
     * @param q
     * @return
     */
    @Override
    public boolean isConnected(int p, int q) {
        return find(p) == find(q);
    }

    /**
     * 合并元素pq所属的集合
     * O(h)
     * @param p
     * @param q
     */
    @Override
    public void unionElements(int p, int q) {
        int pRoot = find(p);
        int qRoot = find(q);

        if (pRoot == qRoot) {
            return ;
        }

        /*
         * 根据两个元素所在树的rank不同判断合并方向
         * 将rank低的集合合并到rank高的集合上
         * 并不实际反应节点的深度/高度值
         */
        if (rank[pRoot] < rank[qRoot]) {
            parent[pRoot] = qRoot;   // pRoot指向qRoot

        } else if (rank[qRoot] < rank[pRoot]) {
            parent[qRoot] = pRoot;
        } else {
            parent[qRoot] = pRoot;
            rank[pRoot] += 1;
        }
    }
}

版本六的性能不一定高于版本五，递归是有一定的性能开销的
在版本五中，多执行几次find操作也是可以将树的高度压缩为2的，例如再一次执行find(4)+find(3)：
在这里插入图片描述
在这里插入图片描述

时间复杂度分析

加入路径压缩后并查集的时间复杂度严格意义上为： O ( l o g ∗ n ) − > i t e r a t e d    l o g a r i t h m O(log^*n)->iterated\,\,logarithm O(log∗n)−>iteratedlogarithm
l o g ∗ n = { 0  if  n ≤ 1 1 + l o g ∗ ( l o g n )  if  n > 1 log^*n=\begin{cases} 0 & \text{ if } n \le 1 \\ 1+log^*(logn) & \text{ if } n > 1 \end{cases} log∗n={01+log∗(logn)​ if n≤1 if n>1​
近乎是 O ( 1 ) O(1) O(1)级别的。

应用

  • 连接问题 Connectivity Problem
    • 网络中节点间的连接状态
    • 数学中的集合类实现

Reference

xylitolz
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【高级数据结构】并查集
繁凡さん的博客
08-20 386
A、AcWing 1250. 格子游戏 #include<bits/stdc++.h> using namespace std; const int N = 500007; int n, m; int fa[N]; bool flag; int get(int x, int y){ return x * n + y; } int find(int x){ if(fa[x] == x)return x; return fa[x] = find(fa[x]); }
高级数据结构 | 并查集
偶然i的博客
08-11 156
并查集原理 在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集 合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-fifind set)。 并查集一般可以解决一下问题： 1. 查找元素属于哪个集合 沿着数组表示树形关系以上一直找到根(即：树中中元素为负数的位置) 2. 查看两个元素是否属于同一个集合 ...
高级数据结构：并查集
lafea的博客
01-29 177
文章目录#写在前面##格子游戏----c++版 #写在前面 基础并查集实现了 合并两个集合 查询某个元素的祖宗节点 基本优化 路径压缩 O(logn) 按秩合并 主要思想是合并集合时每次把树的深度较小的一个合并到深度较大的那一个 代码比较长 O(logn) 两个一起可以做到 O(α(n)) 反阿克曼函数 -阿克曼函数 阿克曼函数增长很快，反阿克曼函数增长很慢 基本看成 O(1) 的 并查集扩展 记录一下每个集合的大小，将集合大小这个属性绑定到根节点上 记录一下每个点到根节点的距离，这里需要绑
高级数据结构之并查集
Sy_LeeChan的博客
05-29 289
高级数据结构之并查集 1.并查集介绍 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。 并查集是一
Redis 交集并集差集
ppjsyw的博客
05-21 4753
介绍 交集:在所有集合中出现过至少两次的元素 并集:将两个集合的元素合并到一起，并去掉重复元素 差集:在集合1中存在，但在集合2中不存在的值 相关命令 命令 说明 sinter key [key …] 获取所有集合的交集 sinterstore desitination key [key …] 获取所有集合的交集并覆盖掉desitination集合的值 sunion key [key …] 获取所有集合中的所有元素并去重 sunionstore destination key
数据结构算法
05-02
经典算法题每日演练——第十五题 并查集 经典算法题每日演练——第十四题 Prim算法 经典算法题每日演练——第十三题 赫夫曼树 经典算法题每日演练——第十二题 线段树 经典算法题每日演练——第十一题 Bitmap算法 ...
Android开发资料合集-World版！
12-11
9.36、从输入流中获取数据并以字节数组返回 250 9.37、通过ANDROID 客户端上传数据到服务器 251 9.38、文件下载类 255 9.39、下载文件的进度条提示 263 9.40、通过HTTPCLIENT从指定SERVER获取数据 265 9.41、通过FTP...
Microsoft SQL Server 2008技术内幕：T-SQL查询(第二卷)
10-22
主要内容包括SQL的基础理论、查询优化、查询算法及复杂度，以及在使用子查询、表表达式、排名函数、数据聚合和透视转换、TOP和APPLY、数据修改、分区表、特殊数据结构等实际应用时会遇到的各种高级查询问题和解决...
hibernate 框架详解
06-07
高级集合映射（Advanced collection mappings） 7.3.1. 有序集合（Sorted collections） 7.3.2. 双向关联（Bidirectional associations） 7.3.3. 三重关联（Ternary associations） 7.3.4. 使用 7.4. 集合...
深入云计算 MongoDB管理与开发实战详解pdf.part2
05-20
《深入云计算(MongoDB管理与开发实战详解)》系统全面的介绍了MongoDB开发、管理、维护和性能优化等方方面面。详细而深入，对MongoDB的开发和管理方法进行了详细的讲解，也对MongoDB的工作机制进行了深入的探讨。注重...
高级数据结构（并查集、树状数组、线段数）
08-03
并查集、树状数组、线段数三种高级数据结构的PPT，以及一些论文
高阶数据结构之并查集
Morn_Star_Oliver的博客
07-17 166
并查集是什么，使用，相关OJ
高级数据结构设计－－并查集及实现学习笔记（有趣篇）
逍遥小章
09-28 1015
并查集的程序设计：   为了解释并查集的原理，我将举一个更有趣的例子。 话说江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的，就免不了要打一架。但大侠们有一个优点就是讲义气，绝对不打自己的朋友。而且他们信奉“朋友的朋友就是我的朋友”，只要是能通过朋友关系串联起来的，不管拐了多少个弯，都认为是自己人。这样一来，江湖上就
高级数据结构—并查集
xuemengliyou的博客
01-26 145
高级数据结构 并查集
高级数据结构——并查集基本操作
ly's Blog
04-21 842
1.并查集概述： a.什么叫并查集？ 从字面意思理解，并就是合并，查就是查询，集就是集合的意思。 并查集是一种用于分离集合操作的抽象数据结构类型。它所处理的是集合之间的关系，即动态维护和处理集合元素之间复杂的关系，当给出两个元素的一个无序对(a,b)时，需要快速合并a和b所在的集合，这期间需要反复查找某个元素所在的集合。 b.简介： 在这种数据类型中，n个不同的元素被分为若干组，每组是一个集合，这...
数据结构与算法：Trie字典树
xylitolz的博客
10-07 298
文章目录Trie什么是TrieTrie树的3个基本性质Trie的应用Trie与其他相关数据结构的对比Trie的局限性更多字符串问题实现TrieTrie的节点结构向Trie中添加一个新的单词word(不会重复)查询单词word是否在Trie中查询是否在Trie中有单词以prefix为前缀完整代码练习题目Reference Trie 什么是Trie 字典树：又称单词查找树/前缀树/Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引.
并查集
loser与你
09-22 90
并查集  并查集要解决的问题就是并和查，并就是将两个集合合并成一个新的集合，查就是查两个个元素是否在同一个集合中。  因而其提供给用户的接口也应该为两个，一个isSameSet()方法用于查，一个union()方法用于并。  显然，如果是用链表来实现的话，并是一个O(1)的操作，但是查将会是O(n)的操作；而如果用哈希表来实现的话，查是一个O(1)的操作，但是并将会是O(n)的操作。因而，通常情况下使用的是类似链表+哈希表的形式。  原理就是设置头元素来表示一个集合的起始位置，初始情况下，每个元素就是自己集
Linux内核的IO模型详解
xylitolz的博客
08-29 515
文章目录一、什么是IO二、Linux内核的IO模型2.1 概念说明2.1.1 用户空间和内核空间2.1.2 进程切换2.1.3 进程的阻塞2.1.4 文件描述符2.1.5 缓存 IO2.2 同步阻塞2.3 同步非阻塞2.4 IO复用2.5 信号驱动2.6 异步非阻塞 本篇文章已同步更新至Github仓库JavaSummary，欢迎star! 一、什么是IO 在Linux的世界，一切皆文件。而文件是什么呢，文件就是一串二进制流。不管socket、FIFO、管道还是终端，对我们来说，一切都是流。在信息的交
数据结构线性结构详解
最新发布
08-22
数据结构中的线性结构是指元素之间存在一对一的关系，形成一个有序的序列。常见的线性结构有数组和链表两种形式。 数组是一种连续存储的线性结构，元素在内存中按照顺序排列。数组具有随机访问的特点，即可以通过索引直接访问任意位置的元素。然而，数组的插入和删除操作需要移动大量元素，因此时间复杂度是O(N)，其中N是数组的长度。 链表是一种离散存储的线性结构，元素在内存中通过指针连接起来。链表的插入和删除操作只需要修改指针指向，因此时间复杂度是O(1)。然而，链表的随机访问需要遍历整个链表，时间复杂度是O(N)。 为了综合数组和链表的优势，我们可以使用哈希表这种数据结构。哈希表通过哈希函数将元素映射到数组中的一个位置，每个位置对应一个链表。当插入或查找元素时，先通过哈希函数计算出元素在数组中的位置，然后在相应的链表中进行操作。这样，哈希表既可以快速定位元素，又可以高效地进行插入和删除操作。 拉链法是哈希表最常用的一种实现方法。它将哈希表中的每个位置都看作一个链表，当多个元素通过哈希函数映射到同一个位置时，它们会被依次连接成一个链表。这样，哈希表中的每个位置都可以容纳多个元素，解决了冲突的问题。 综上所述，线性结构包括数组和链表，而哈希表则是一种综合了数组和链表优势的数据结构。而拉链法是哈希表最常用的实现方法之一，通过将哈希表中的每个位置看作一个链表，解决了元素冲突的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [数据结构讲解 ---- 线性结构详解](https://blog.csdn.net/fengyuyeguirenenen/article/details/122675420)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [详解Redis数据结构之跳跃表](https://download.csdn.net/download/weixin_38617604/14831886)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xylitolz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值