常用算法（待完善...)

排序算法

归并排序

内存淘汰算法

LRU（Least Recently Used，最近最少使用）

力扣 146. LRU 缓存

点击查看代码

class LRUCache {
 
    // 内部类，实现双向链表。链表队首约定为最近使用的元素
    private static class Node{
        int key, value;
        Node prev, next;
        
        Node(int k, int v){
            key = k;
            value = v;
        }
    }
 
    private final int capacity;
    // 双向链表 + 哈希表
    private final Node dummy = new Node(0,0);
    private final Map<Integer, Node> keyToNode = new HashMap<>();
 
    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.next = dummy;
        dummy.prev = dummy;
    }
    
    // 获取元素
    public int get(int key) {
        // 1.判断元素是否存在, 并且更新其使用状态
        Node node = getNode(key);
        // 2.存在，返回对应元素
        if (node != null) {
            return node.value;
        }
        // 3.不存在，返回-1
        return -1;
    }
    
    // 放入元素
    public void put(int key, int value) {
        // 1.判断元素是否存在, 并且更新其使用状态
        Node node = getNode(key);
        // 2.存在，覆盖元素
        if (node != null){
            node.value = value;
            return;
        }
        // 3.不存在，在链表首部增加元素,并将key加入map中
        node = new Node(key, value);
        pushFront(node);
        keyToNode.put(key, node);
        // 3.1.是否超出容量限制
        if (keyToNode.size() > capacity) {
            // 3.1.1. 超出限制，需要淘汰队尾（最近最少使用）
            Node backNode = dummy.prev;
            keyToNode.remove(backNode.key);
            remove(backNode);
        }
    }
 
    // 获取对应key上的元素， 没有则返回null
    private Node getNode(int key){
        // 1. 哈希表中没有key，返回null，说明没有key对应的节点
        if (!keyToNode.containsKey(key)) {
            return null;
        }
        // 2. 找到对应元素
        Node node = keyToNode.get(key);
        // 3.最近使用的元素
        // 3.1.先移除
        remove(node);
        // 3.2.再添加到队首，作为最近使用的元素
        pushFront(node);
        return node;
    }
 
    private void remove(Node node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
 
    private void pushFront(Node node){
        node.prev = dummy;
        node.next = dummy.next;
        dummy.next.prev = node;
        dummy.next = node;
    }
}