并查集和LRUCache

最新推荐文章于 2023-09-18 10:56:49 发布

沐晴0128

最新推荐文章于 2023-09-18 10:56:49 发布

阅读量253

点赞数

文章标签：并查集 LRUCache

本文链接：https://blog.csdn.net/qq_53190275/article/details/131363980

版权

3.JDK中类似LRUCahe的数据结构LinkedHashMap

4.LRU Cache的OJ

1. 并查集

1.1原理

把不同的元素划分到不想交的集合.开始时,每个元素自成一个单元集合,然后按照规律把是同一组的元素集合合并

s1={0,6,7,8}，s2={1,4,9}，s3={2,3,5}

结论:

1.元素下标对应集合中元素的编号例如:array[8]的值0是8的父亲

2.如果有负号,负号代表根,数字代表集合的元素个数

3.如果为非负数,为父亲在数组的下标

问题:

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

根据数组表示的树形关系找根

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

根据数组表示的树形关系找根,如果根相同表示在同一个集合

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

A集合改为B集合的名称,B集合数为两个集合数数之和

4. 集合的个数

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

1.2实现

public class UnionFindSet {
    public int[] elem;

    public  UnionFindSet(int n){
        this.elem=new int[n];
        Arrays.fill(elem,-1);
    }
    //找根
    public int findRoot(int x){
        if(x<0){
            throw  new IndexOutOfBoundsException();
        }
        while(elem[x]>0){//值为负数为根
            x=elem[x];
        }
        return x;
    }
    //判断是不是一个集合
    public boolean isSame(int x1,int x2){
        int index1=findRoot(x1);
        int index2=findRoot(x2);
        return index1==index2 ? true :false;
    }
    //合并
    public void union(int x1,int x2){
        int index1=findRoot(x1);
        int index2=findRoot(x2);
        if(index1==index2) return;
        elem[index1]=elem[index1]+elem[index2];
        elem[index2]=index1;
    }
    //根的个数
    public int getCount(int x){
        int count=0;
        for(int s:elem){
            if(s<0){
                count++;
            }
        }
        return count;
    }
    public void print(){
        for(int x:elem){
            System.out.print(x+" ");
        }
        System.out.println();
    }
}

1.3应用

1.3.1省份数量

把为1的合并,输出集合的个数

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

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

    //找根节点
    public int find(int x){
        if(x < 0) {
            throw new IndexOutOfBoundsException("下标不合法，是负数");
        }
        while(elem[x]>=0){
            x=elem[x];
        }
        return x;
    }


    //是否在一个集合
    public boolean isSame(int x1,int x2){
        int index1=find(x1);
        int index2=find(x2);
        return index1==index2 ?true :false;
    }
    //合并
    public void union(int x1,int x2){
        int index1=find(x1);
        int index2=find(x2);
        if(index1==index2) return ;
        elem[index1]=elem[index1]+elem[index2];
        elem[index2]=index1;
    }


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

1.3.2等式方程的可满足性

把是==的两个放到一个集合,检查!=两个的是否在一个集合,如果不在==>满足

class Solution {
    public boolean equationsPossible(String[] equations) {
        UnionFindSet UnionFindSet=new UnionFindSet(26);
        for(int i=0;i<equations.length;i++){
            if(equations[i].charAt(1)=='='){
                UnionFindSet.unoin(equations[i].charAt(0)-'a',equations[i].charAt(3)-'a');
            }
        }
        for(int i=0;i<equations.length;i++){
            if(equations[i].charAt(1)=='!'){
                  int root1=  UnionFindSet.find(equations[i].charAt(0)-'a');
                int root2= UnionFindSet.find(equations[i].charAt(3)-'a');
                if(root1==root2){
                    return false;
                }
            }
        }
        return true;
}
}

public class UnionFindSet {
    public int[] elem;

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

    //找根
    public int find(int x){
        if(x<0){
            throw new IndexOutOfBoundsException("下标不合法，是负数");
        }
        while(elem[x]>=0){
            x=elem[x];
        }
        return x;

    }

    //是不是在一个集合
    public boolean isSame(int x1,int x2){
        int index1=find(x1);
        int index2=find(x2);
        return index1==index2 ?true:false;
    }


    //合并
    public void unoin(int x1,int x2){
        int index1=find(x1);
        int index2=find(x2);
        if(index1==index2) return;
        elem[index1]=elem[index1]+elem[index2];
        elem[index2]=index1;
    }
}

2.LRUCache

1.概念

一种Cache替换算法,把最近少使用的内容替换掉

2.实现

用双向链表和哈希表搭配

双向链表可以实现任意位置O(1)的插入和删除，使用哈希表是因为哈希表(快速定位)的增删查改也是O(1)。

3.JDK中类似LRUCahe的数据结构LinkedHashMap

参数说明：

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

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

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

示例1：当值为false的时候基于插入顺序

LinkedHashMap<String,Integer> linkedHashMap=
        new LinkedHashMap<String,Integer>(16, (float) 0.7,false);
linkedHashMap.put("mq",1);
linkedHashMap.put("haha",11);
linkedHashMap.put("hello",12);
System.out.println(linkedHashMap);
System.out.println("获取元素");
System.out.println(linkedHashMap.get("haha"));
System.out.println(linkedHashMap);

示例2：当值为true的时候基于访问顺序

LinkedHashMap<String,Integer> linkedHashMap=
        new LinkedHashMap<String,Integer>(16, (float) 0.7,true);
linkedHashMap.put("mq",1);
linkedHashMap.put("haha",11);
linkedHashMap.put("hello",12);
System.out.println(linkedHashMap);
System.out.println("获取元素");
System.out.println(linkedHashMap.get("haha"));
System.out.println(linkedHashMap);

访问过的放到尾部

4.LRU Cache的OJ

public class LRUCache extends  LinkedHashMap<Integer,Integer>{
    public int capacity;
    LRUCache(int capacity){
        //true基于访问顺序
        super(capacity,0.75f,true);
        this.capacity=capacity;

    }
    @Override
    public Integer get(Object key) {
        return super.getOrDefault(key,-1);
    }

    @Override
    public Integer put(Integer key, Integer value) {
        return super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size()>capacity;
    }
}

public class LRUCache {
    static class DLinkNode{
        public  int key;
        public int val;
        public DLinkNode prev;
        public DLinkNode next;

        public DLinkNode(){

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

        @Override
        public String toString() {
            return "{ key=" + key + ", val=" + val+"} ";
        }
    }

    public  DLinkNode head;
    public DLinkNode tail;
    public  int usedSize;//有效数据个数
    public Map<Integer,DLinkNode>   cache;
    public int capacity;//默认容量

    public  LRUCache(int capacity){
        this.head=new DLinkNode();
        this.tail=new DLinkNode();
        head.next=tail;
        tail.prev=head;
        cache=new HashMap<>();
        this.capacity=capacity;
    }

    /**
     * 存储元素
     * 1.查找是否存储过
     * 2.没有
     * 2.1 实例化结点
     * 2.2 存储到map中
     * 2.3 将该结点移动到尾结点(新插入的)
     * 2.4 检查当前有效个数是不是超过capacity
     * 2.5 超过,去掉头结点
     * 2.6 清除缓存中的元素
     * 2.7 usedSize--
     * 3.有
     * 3.1 更新key对应的val
     * 3.2 将该结点移动到尾结点(新插入的)
     * @param key
     * @param val
     */
    public  void  put(int key,int val){
        DLinkNode node=cache.get(key);
        if(node==null){
            DLinkNode dLinkNode=new DLinkNode(key,val);
            cache.put(key,dLinkNode);
            addToTail(dLinkNode);
            usedSize++;
            if(usedSize>capacity){
                DLinkNode dLinkNode1=removeHead();
                cache.remove(dLinkNode1.key);//清除
                usedSize--;
            }
        }else{
            node.val=val;
            moveToTail(node);
        }
    }

    /**
     * 移除当前结点到尾结点
     */
    private void moveToTail(DLinkNode node) {
        //1.删除
        node.prev.next=node.next;
        node.next.prev=node.prev;
        //2.加到尾部
        addToTail(node);
    }

    /**
     * 插入到尾结点
     * @param node
     */
    private void addToTail(DLinkNode node){
        tail.prev.next=node;
        node.prev=tail.prev;
        node.next=tail;
        tail.prev=node;
    }

    /**
     * 移除第一个结点
     * @return
     */
    private DLinkNode removeHead(){
        DLinkNode del=head.next;
        head.next=del.next;
        del.next.prev=head;
        return del;
    }



    /**
     * 把访问的结点放到尾巴
     * @return
     */
    public int get(int key){
        DLinkNode node=cache.get(key);
        if(node==null){
            return -1;
        }
        moveToTail(node);
        return node.val;
    }
}