并查集&LRU Cache

最新推荐文章于 2024-09-13 19:36:07 发布
最新推荐文章于 2024-09-13 19:36:07 发布
阅读量870 收藏 3
点赞数 3
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73869209/article/details/134777652
版权
本文介绍了并查集和LRUCache这两种数据结构，包括并查集的基本原理、实现以及在实际问题中的应用，同时详细讲解了LRUCache的工作原理、JDK中的LinkedHashMap实现以及自定义LRUCache的哈希+双向链表实现。
摘要由CSDN通过智能技术生成

目录

前言

一 . 并查集

1.1  并查集原理

1.2 并查集的实现

二 . LRU Cache

2.1 什么是LRU Cache

2.2 LRU Cache实现

2.3 JDK中类似LRUCahe的数据结构LinkedHashMap

2.4 自己实现链表

总结

前言

大家好,今天给大家介绍两种数据结构并查集&LRU Cache

一 . 并查集

1.1  并查集原理

在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-find set)。   

  比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，武汉招3人，10个人来自不同的学校， 起先互不相识，每个学生都是一个独立的小团体，现给这些学生进行编号：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 给以下 数组用来存储该小集体，数组中的数字代表：该小集体中具有成员的个数。(负号下文解释)

毕业后，学生们要去公司上班，每个地方的学生自发组织成小分队一起上路，于是：

西安学生小分队s1={0,6,7,8}，成都学生小分队s2={1,4,9}，武汉学生小分队s3={2,3,5}就相互认识了，10个 人形成了三个小团体。假设右三个群主0,1,2担任队长，负责大家的出行。

一趟火车之旅后，每个小分队成员就互相熟悉，成为了一个朋友圈。

从上图可以看出：编号6,7,8同学属于0号小分队，该小分队中有4人(包含队长0)；编号为4和9的同学属于1号 小分队，该小分队有3人(包含队长1)，编号为3和5的同学属于2号小分队，该小分队有3个人(包含队长1)。

仔细观察数组，可以得出以下结论：

1. 数组的下标对应集合中元素的编号

2. 数组中如果为负数，负号代表根，数字代表该集合中元素个数

3. 数组中如果为非负数，代表该元素双亲在数组中的下标

在公司工作一段时间后，西安小分队中8号同学与成都小分队1号同学奇迹般的走到了一起，两个小圈子的学 生相互介绍，最后成为了一个小圈子：

现在0集合有7个人，2集合有3个人，总共两个朋友圈。

通过以上例子可知，并查集一般可以解决一下问题：

1. 查找元素属于哪个集合

沿着数组表示树形关系以上一直找到根(即：树中中元素为负数的位置)

2. 查看两个元素是否属于同一个集合

沿着数组表示的树形关系往上一直找到树的根，如果根相同表明在同一个集合，否则不在

3. 将两个集合归并成一个集合

将两个集合中的元素合并 将一个集合名称改成另一个集合的名称

4. 集合的个数 

遍历数组，数组中元素为负数的个数即为集合的个数。

1.2 并查集的实现

没什么难度,大家自己看看就好

/**
 * 并查集
 */
public class UnionFindSet {
    private int[] elem;
    private int usedSize;

    public UnionFindSet(int capacity) {
        elem = new int[capacity];
        Arrays.fill(elem,-1);
    }

    /**
     * 查找一个数据的根节点
     * @param x
     * @return 下标
     */
    public int findRoot(int x){
        if(x < 0){
            throw new IndexOutOfBoundsException("数组越界,下标不合法!");
        }
        while(elem[x] >= 0){
            x = elem[x];
        }
        return x;
    }

    /**
     * 查询两个数字是否在同一个集合
     * @param x1 数字一
     * @param x2 数字二
     * @return 在同一个集合返回true反之返回false
     */
    public boolean isSameUnionFindSet(int x1,int x2){
        return findRoot(x1) == findRoot(x2);
    }

    /**
     * 合并操作[合并的是根节点]
     * @param x1
     * @param x2
     */
    public void union(int x1,int x2){
        int rootIndex1 = findRoot(x1);
        int rootIndex2 = findRoot(x2);
        if(rootIndex1 == rootIndex2){
            return;
        }
        elem[rootIndex1] = elem[rootIndex1]+elem[rootIndex2];
        elem[rootIndex2] = rootIndex1;
    }

    /**
     * 集合的个数
     * @return
     */
    public int getCount(){
        int count = 0;
        for (int i : elem) {
            if(i < 0){
                count++;
            }
        }
        return count;
    }

    public void print(){
        for (int i : elem) {
            System.out.print(i+" ");
        }
    }


    public static void main(String[] args) {
        UnionFindSet unionFindSet = new UnionFindSet(10);
        System.out.println("合并: 0和6");
        unionFindSet.union(0,6);
        System.out.println("合并: 0和7");
        unionFindSet.union(0,7);
        System.out.println("合并: 0和8");
        unionFindSet.union(0,8);
        System.out.println("合并: 1和4");
        unionFindSet.union(1,4);
        System.out.println("合并: 1和9");
        unionFindSet.union(1,9);
        System.out.println("合并: 2和3");
        unionFindSet.union(2,3);
        System.out.println("合并: 2和5");
        unionFindSet.union(2,5);

        unionFindSet.print();

        System.out.println("合并: 8和1");
        unionFindSet.union(8,1);

        unionFindSet.print();

        System.out.println(unionFindSet.isSameUnionFindSet(6, 9));
    }
}

练手题 

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
    private int[] elem;
    private int usedSize;

    public int findCircleNum(int[][] isConnected) {
        elem = new int[isConnected.length];
        Arrays.fill(elem,-1);
        for(int i = 0; i<isConnected.length; i++){
            for(int j = 0; j<isConnected[0].length; j++){
                if(isConnected[i][j] == 1)
                    union(i,j);
            }
        }
        return getCount();
    }

    /**
     * 查找一个数据的根节点
     * @param x
     * @return 下标
     */
    public int findRoot(int x){
        if(x < 0){
            throw new IndexOutOfBoundsException("数组越界,下标不合法!");
        }
        while(elem[x] >= 0){
            x = elem[x];
        }
        return x;
    }

    /**
     * 合并操作[合并的是根节点]
     * @param x1
     * @param x2
     */
    public void union(int x1,int x2){
        int rootIndex1 = findRoot(x1);
        int rootIndex2 = findRoot(x2);
        if(rootIndex1 == rootIndex2){
            return;
        }
        elem[rootIndex1] = elem[rootIndex1]+elem[rootIndex2];
        elem[rootIndex2] = rootIndex1;
    }

    /**
     * 集合的个数
     * @return
     */
    public int getCount(){
        int count = 0;
        for (int i : elem) {
            if(i < 0){
                count++;
            }
        }
        return count;
    }
}
class Solution {
    public boolean equationsPossible(String[] equations) {
        UnionFindSet unionFind = new UnionFindSet(26);
        for(String s : equations){
            if(s.charAt(1) == '='){
                unionFind.union(s.charAt(0)-'a',s.charAt(3)-'a');
            }
        }

        for(String s : equations){
            if(s.charAt(1) == '!'){
                boolean flag = unionFind.isSameUnionFindSet(s.charAt(0)-'a',s.charAt(3)-'a');
                if(flag){
                    return false;
                }
            }
        }

        return true;
    }

     /**
     * 并查集
     */
    public class UnionFindSet {
        private int[] elem;
        private int usedSize;
    
        public UnionFindSet(int capacity) {
            elem = new int[capacity];
            Arrays.fill(elem,-1);
        }
    
        /**
         * 查找一个数据的根节点
         * @param x
         * @return 下标
         */
        public int findRoot(int x){
            if(x < 0){
                throw new IndexOutOfBoundsException("数组越界,下标不合法!");
            }
            while(elem[x] >= 0){
                x = elem[x];
            }
            return x;
        }
    
        /**
         * 查询两个数字是否在同一个集合
         * @param x1 数字一
         * @param x2 数字二
         * @return 在同一个集合返回true反之返回false
         */
        public boolean isSameUnionFindSet(int x1,int x2){
            return findRoot(x1) == findRoot(x2);
        }
    
        /**
         * 合并操作[合并的是根节点]
         * @param x1
         * @param x2
         */
        public void union(int x1,int x2){
            int rootIndex1 = findRoot(x1);
            int rootIndex2 = findRoot(x2);
            if(rootIndex1 == rootIndex2){
                return;
            }
            elem[rootIndex1] = elem[rootIndex1]+elem[rootIndex2];
            elem[rootIndex2] = rootIndex1;
        }
    
    }
}

二 . LRU Cache

2.1 什么是LRU Cache

LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是Cache？狭义 的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较 快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度 差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种 意义上的Cache── 称为Internet临时文件夹或网络内容缓存等。

Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有 的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实， LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

2.2 LRU Cache实现

实现LRU Cache的方法和思路很多，但是要保持高效实现O(1)的put和get，那么使用双向链表和哈希表的搭 配是最高效和经典的。使用双向链表是因为双向链表可以实现任意位置O(1)的插入和删除，使用哈希表是因 为哈希表的增删查改也是O(1)。

2.3 JDK中类似LRUCahe的数据结构LinkedHashMap

参数说明：

1. initialCapacity    初始容量大小，使用无参构造方法时，此值默认是16

2. loadFactor    加载因子，使用无参构造方法时，此值默认是 0.75f

3. accessOrder false： 基于插入顺序 true： 基于访问顺序

示例1：当accessOrder的值为false的时候

public static void main(String[] args) {

         Map map = new LinkedHashMap<>(16,0.75f,false);

         map.put("1", "a");

         map.put("2", "b");

         map.put("4", "e");

         map.put("3", "c");

         System.out.println(map);

}

输出结果： {1=a, 2=b, 4=e, 3=c}

以上结果按照插入顺序进行打印

示例2：当accessOrder的值为true的时候

public static void main(String[] args) {

         Map map = new LinkedHashMap<>(16,0.75f,true);

         map.put("1", "a");

         map.put("2", "b");

         map.put("4", "e");

         map.put("3", "c");

         map.get("1");

         map.get("2");

         System.out.println(map);

}

输出结果： {4=e, 3=c, 1=a, 2=b}

每次使用get方法，访问数据后，会把数据放到当前双向链表的最后。

当accessOrder为true时，get方法和put方法都会调用recordAccess方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值false时，从源码中可以看出recordAccess方法什么也不会做。

2.4 自己实现链表

/*
* 最近最久未使用cache替换算法
* 哈希+双向链表
* */
public class LruCache extends LinkedHashMap {

    private final ListNode head; // 傀儡头节点,避免分情况讨论
    private final ListNode tail; // 傀儡尾节点,避免分情况讨论
    private final int capacity;
    private int usedSize;

    private final Map<Integer,ListNode> hash;

    public LruCache(int capacity) {
        this.capacity = capacity;
        hash = new HashMap<>(capacity);
        head = new ListNode();
        tail = new ListNode();
        head.next = tail;
        tail.pre = head;
    }


    /**
     * 获取当前key对应的value
     * @param key
     * @return
     */
    public int get(int key){
        ListNode node = hash.get(key);
        // key 不存在,返回-1
        if(node == null) return -1;
        // key存在,将该节移动至尾部
        moveTail(node);
        return node.val;
    }

    private void moveTail(ListNode node){
        removeNode(node);
        addToTail(node);
    }

    private void addToTail(ListNode node) {
        tail.pre.next = node;
        node.pre = tail.pre;
        node.next = tail;
        tail.pre = node;
    }


    private void removeNode(ListNode node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }


    /**
     * 删除第一个节点的数据
     */
    public ListNode removeHead(){
        ListNode next = head.next;
        head.next = head.next.next;
        head.next.pre = head;
        usedSize--;
        return next;
    }

    /**
     * 添加节点
     * @param key
     * @param value
     */
    public void put(int key,int value){
        /*
        * 1.查看是否存在该key对应的节点
        * 2.如果不存在,在map中添加该key,并在尾部添加节点
        * 3.如果usedSize > capacity 移除头部元素
        * 4.如果存在,将该节点拖到尾部即可
        * */
        ListNode node = hash.get(key);
        // 1.查看是否存在该key对应的节点
        if(node == null){
            node = new ListNode(key,value);
            hash.put(key,node);
            usedSize++;
            // 3.如果usedSize > capacity 移除头部元素
            if(usedSize > capacity){
                ListNode listNode = removeHead();
                hash.remove(listNode.key);
                usedSize--;
            }
            //  4.如果存在,将该节点拖到尾部即可
            addToTail(node);
        }else{
            // 2.如果不存在,在map中添加该key,并在尾部添加节点
            node.val = value;
            // 移动至尾部
            moveTail(node);
        }
    }

    /**
     * 节点内部类
     */
    static class ListNode {
        int val;
        int key;
        ListNode pre;
        ListNode next;

        public ListNode(int key,int val) {
            this.key = key;
            this.val = val;
        }

        public ListNode() {

        }
    }

    public static void main(String[] args) {
        LinkedHashMap<String,Integer> l = new LinkedHashMap(16,0.75f,false);
    }
}

总结

代码都很简单,大家多多理解,下一篇博客见!

喜欢吃animal milk
关注
专栏目录
LRU链表介绍
daha1314的博客
05-07 1652
文章目录 1. 简介 2. LRU 组织 2.1 LRU 链表 2.2 LRU Cache 2.3 LRU 移动操作 2.3.1 page 加入 LRU 2.3.2 其他 LRU 移动操作 3. LRU 回收 3.1 LRU 更新 3.2 Swappiness 3.3 反向映射 3.4 代码实现 3.4.1 struct scan_control 3.4.2 shrink_node() 3.4.3 shrink_list(
Python实现的一个简单LRU cache
12-25
LRU (Least Recently Used) 缓存是一种常用的内存管理策略，用于在有限的存储空间内高效地存储数据。当缓存满时，最近最少使用的数据将被移除以腾出空间给新数据。这里我们将讨论如何使用Python实现一个简单的LRU...
LRU Cache + 并查集
快乐星球
08-16 200
什么是LRU Cache LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 什么是 Cache? 狭义的Cache指的是位于CPU和主存间的快速RAM， 广义上的Cache指的是位于速度相差较大的两种 硬件之间， 用于协调两者数据传输速度差异的结构。 除了CPU与主存之间有Cache， 内存与硬盘 之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或 网络内容缓存等。 为什么要用LRU ？ Cache的
请回答数据结构-【并查集&LRUCache】
Allen9012的博客
07-26 336
仅仅这两个结构是不足够的因为达不到O(1)，因为虽然map能找到位置，但是插入删除还是效率不够，找到值是O(1)，虽然知道了key对应的在Map的位置，但是还需要调整List中使顺序到最后去，此时还不知道key在List的位置，所以我们想到了map的value存的是list的迭代器。由于之前的并查集是只能接收整数，所以我们对于小写字母可以进行映射，把[a-z]26个英文字母，将他们进行[0,25]一一对应映射，这个问题同样可能发生在上一题省份，如果给的不是下标，而是字符串，省份名，就需要建立映射关系。...
高阶数据结构（3）并查集：并查集原理、并查集实现、并查集应用；LRUCache：概念、LRU Cache的实现、JDK中类似LRUCahe的数据结构LinkedHashMap、LRU Cache的OJ
m0_74343467的博客
12-05 146
高阶数据结构（3）并查集：并查集原理、并查集实现、并查集应用；LRUCache：概念、LRU Cache的实现、JDK中类似LRUCahe的数据结构LinkedHashMap、LRU Cache的OJ
【高阶数据结构(一)】并查集详解
杭电码农-NEO的博客
05-06 1438
本篇文章讲解了并查集的原理,并查集的模拟实现,并查集的应用.
Caffeine Cache-高性能Java本地缓存之王(基于LRU算法的优化策略)
ice-wee的专栏
08-22 2948
前面刚说到Guava Cache，他的优点是封装了get，put操作；提供线程安全的缓存操作；提供过期策略；提供回收策略；缓存监控。当缓存的数据超过最大值时，使用LRU算法替换。这一篇我们将要谈到一个新的本地缓存框架：Caffeine Cache。它也是站在巨人的肩膀上-Guava Cache，借着他的思想优化了算法发展而来。 本篇博文主要介绍Caffine Cache 的使用方式，以及Caffine Cache在SpringBoot中的使用。 1. Caffine Cache 在算法上的优点-W-Ti
并查集--
qq_55956945的博客
05-09 240
文章目录b树 #include<iostream> #include<vector> using namespace std;//x是数组的下标 class UnionFindSet { public: //一开始每一个都表示一个独立的集合 UnionFindSet(size_t n) { _v.resize(n, -1); } int FindRoot(int x) { //一直找到负数停止 while (_v[x] >= 0) { .
使用线程安全型双向链表实现简单 LRU Cache 模拟
热门推荐
苏州程序大白的博客
11-16 1万+
使用线程安全型双向链表实现简单 LRU Cache 模拟目录????博主介绍前言1、动机1.1、要解决的问题2、系统设计2.1、系统总体框架2.2、系统功能模块2.3 系统整体流程3、数据结构设计4、关键技术与系统实现4.1、生成访问序列4.2 各进程的推进4.3、修改链表结构的相关方法实现4.4、访问链表的相关方法实现4.5、应用封装层的实现4.6、统计缓冲区命中率5、系统运行结果5.1、运行环境5.2、运行与测试结果5.2.1、运行结果5.2.2、链表方法测试6、调试与改进????作者相关的文章、资源分
0410-算法复盘-设计LRU缓存结构、并查集Union-Find算法(路径压缩递归、迭代)
Gopuwe的博客
04-10 662
1.设计LRU缓存结构 LRU算法是指最近最久未使用，初次接触是在操作系统中，在虚拟内存，当内存空间不足时需要将一些段或者页淘汰出内存中，从而加载新的段页进来 设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是
lru-cache-2.5.0.zip
09-26
LRU Cache（Least Recently Used 缓存）是一种常见的数据结构，用于存储有限数量的数据，并在内存容量达到上限时，优先淘汰最近最少使用的数据。在IT领域，LRU Cache被广泛应用于缓存系统，如数据库查询缓存、操作...
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1069
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 805
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 578
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 767
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 655
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 936
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
数据结构——栈和队列（队列的定义、顺序队列以及链式队列的基本操作）
weixin_74209413的博客
09-13 1192
队列和栈一样，也是限定只能在表的“端点”进行的线性表。队列在插入的时候，只能在表尾进行插入，在删除的时候，只能在表头进行删除。（先进先出），表尾即队尾，表头即队头。栈和队列是线性表的子集（是插入和删除位置受限的线性表）由于队列的操作具有先进先出的特性，使得队列成为程序设计中解决类似排队问题的有用工具。队列的逻辑结构与同线性表相同，仍为一对一关系。队列的存储结构有顺序队和链队，以循环顺序队列更常见。关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

喜欢吃animal milk

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

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

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

打赏作者

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

抵扣说明：

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

余额充值