标签：node DLinkedNode next 链表 源码 key 解析 节点

LRU

LRU（Least Recently Used，最近最久未使用）是一种常见的页面置换算法，在计算中，所有的文件操作都要放在内存中进行，然而计算机内存大小是固定的，所以我们不可能把所有的文件都加载到内存，因此我们需要制定一种策略对加入到内存中的文件进项选择。

LRU的设计原理就是，当数据在最近一段时间经常被访问，那么它在以后也会经常被访问。这就意味着，如果经常访问的数据，我们需要然其能够快速命中，而不常访问的数据，我们在容量超出限制内，要将其淘汰。

实现自己的lru算法：
leetcode 146. LRU 缓存

哈希表 + 双向链表

图解原理：

1.先给双向链表设置头尾节点dummy head/dummy tail，因为链表长度capacity是2，接着往缓存里放两个kv塞满

2.每次get操作代表该数据最近被使用过，这里做了get(1)操作，所以要把1节点放到链表头部

3.这时候再put数据，这么尾部的节点就被删除，put进来的节点放到头部

代码：

public class LRUCache {
        class DLinkedNode {
            int key;
            int value;
            DLinkedNode prev;
            DLinkedNode next;
            public DLinkedNode() {}
            public DLinkedNode(int _key, int _value) {key = _key; value = _value;}
        }

        private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
        private int size;
        private int capacity;
        private DLinkedNode head, tail;

        public LRUCache(int capacity) {
            this.size = 0;
            this.capacity = capacity;
            // 使用伪头部和伪尾部节点
            head = new DLinkedNode();
            tail = new DLinkedNode();
            head.next = tail;
            tail.prev = head;
        }

        public int get(int key) {
            DLinkedNode node = cache.get(key);
            if (node == null) {
                return -1;
            }
            // 如果 key 存在，先通过哈希表定位，再移到头部
            moveToHead(node);
            return node.value;
        }

        public void put(int key, int value) {
            DLinkedNode node = cache.get(key);
            if (node == null) {
                // 如果 key 不存在，创建一个新的节点
                DLinkedNode newNode = new DLinkedNode(key, value);
                // 添加进哈希表
                cache.put(key, newNode);
                // 添加至双向链表的头部
                addToHead(newNode);
                ++size;
                if (size > capacity) {
                    // 如果超出容量，删除双向链表的尾部节点
                    DLinkedNode tail = removeTail();
                    // 删除哈希表中对应的项
                    cache.remove(tail.key);
                    --size;
                }
            }
            else {
                // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
                node.value = value;
                moveToHead(node);
            }
        }

        private void addToHead(DLinkedNode node) {
            node.prev = head;
            node.next = head.next;
            head.next.prev = node;
            head.next = node;
        }

        private void removeNode(DLinkedNode node) {
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }

        private void moveToHead(DLinkedNode node) {
            removeNode(node);
            addToHead(node);
        }

        private DLinkedNode removeTail() {
            DLinkedNode res = tail.prev;
            removeNode(res);
            return res;
        }
    }

因为是双向链表，节点类就要设置prev/next

其他字段：

• 缓存cache用哈希表，注意这里的kv，value存的是节点类
• 容量capacity表示最大容量，size表示插入时候的大小，用来与capacity进行比较
• 默认的头尾节点head/tail

然后构造函数没啥好说的

get操作：就是简单的取map，但是LRU多了两个步骤：1.删除当前节点，2.移动该节点到链表头部。

复习下链表的增删节点：其实就是把prev和next的指针分别指向新的节点，removeNode方法把当前节点的prev节点的next指针指向tail节点，把当前节点的next节点的prev指针指向当前节点的prev节点，addToHead同理

put操作：先判断存不存在，存在就覆盖+移节点至头部；不存在就新增+移节点至头部+判断长度，长度超容量了就删尾部节点

LinkedHashMap源码解析

java中LinkedHashMap直接实现了LRU，需要看源码来了解其实现机制

众所周知 HashMap 底层是数组+红黑树+链表，是无序的，而 LinkedHashMap 刚好就比 HashMap 多这一个功能，可以按两种顺序排列:

• 按照插入的顺序
• 按照读取的顺序

其内部基于LRU，也是建立双向链表来维护顺序

每次插入/删除后，都会调用下图这三个函数来进行双向链表的维护

Redis内存淘汰机制

可以看出redis也是基于LRU的改动来实现内存淘汰

标签：node,DLinkedNode,next,链表,源码,key,解析,节点
来源： https://blog.csdn.net/Koikoi12/article/details/122719531

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。