LRU (最近最少使用页面置换算法) 的代码实现_lru代码

阅读之前推荐先阅读博主关于LinkedHashMap的文章，传送地址：LinkedHashMap源码分析，基于JDK1.8逐行分析

LRU算法的实现

1. 题目描述

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制

实现 LRUmap 类：

• LRUmap(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1
• void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限capacity时，应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间

进阶：是否可以在 O(1) 时间复杂度内完成这两种操作？

2. LRU算法的介绍

• 全称为最近最少使用，是一种缓存淘汰策略，也就是说认为最近使用过的数据应该是有用的，很久都没使用过的数据应该是无用的，内存满了就优先删除那些很久没有使用过的数据

• 对应到数据结构表述的就是最常使用的元素将其移动至头部或尾部，这就会导致很久没有使用过的元素会被动的移动至另一边，最先删除的元素是最久没有被使用过的元素（注意不是使用次数最少的元素，这是LFU算法）

  • get一个元素时算是访问该元素，需要将此元素移动至头部或尾部，表示最近使用过
  • put一个元素时算是访问该元素，需要将此元素插入到头部或尾部，表示最近使用过

3. 数据结构的选择

3.1 为什么不使用数组？

数组查找一个元素的时间复杂度为O(1)，但其删除元素后将元素整体移动的时间复杂度为O(n)，不满足题意

3.2 为什么不使用单向链表？

链表 添加 / 删除 元素的时间复杂度为O(1)，如果删除的是头节点则满足题意

但如果删除的是链表的中间节点，需要保存待删除节点的前一个节点，且遍历到待删除节点的时间复杂度为O(n)，不满足题意

3.3 为什么使用HashMap + 双向链表？

HashMap寻找待删除节点只需要O(1)的时间复杂度

双向链表删除节点不需要遍历找到待删除结点的前一个节点，故删除任意位置的元素时间复杂度都是O(1)

综上所述：使用HashMap寻找节点，使用双向链表 删除 / 移动 节点，可满足时间复杂度为O(1)的要求

整体结构如下图所示：

4. 代码实现方式一

将刚刚使用过的元素移动到头部，很久没有使用过的元素移动到尾部

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> map = 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;
    }

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

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

    //将节点移动至头部
    private void moveToHead(DLinkedNode node) {
        removeNode(node); //将此节点从链表断开
        addToHead(node); //将断开的节点移动至头部
    }

    //将节点从链表断开
    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //将节点移动至头部
    private void addToHead(DLinkedNode node) {
        node.prev = head; //伪头部节点成为此节点的前一个节点
        node.next = head.next; //原来的第一个节点成为此节点的后一个节点
        head.next.prev = node; //原来的第一个节点向前的指针指向此节点
        head.next = node; //此节点成为伪头部节点的后一个节点
    }

    //删除链表的尾节点
    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev; //删除的其实是伪尾部的前一个节点
        removeNode(res);
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

5. 代码实现方式二

通过LinkedHashMap的源码讲解，自定义LRU缓存可以使用现有的LinkedHashMap，通过制定移除策略、调用 getOrDefault 方法未找到元素时返回 -1 即可，代码如下：

class LRUCache extends LinkedHashMap<Integer, Integer>{
    
    //容量
    private int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1); //未找到元素时返回-1
    }

    //自带的put方法可满足要求，无需改写
    public void put(int key, int value) {
        super.put(key, value);
    }

    //制定移除策略
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity; 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25