剑指offer/LeetCode146/LintCode134_LRU缓存实现

剑指offer/LeetCode146/LintCode134_LRU缓存实现

声明

文章均为本人技术笔记,转载请注明出处:
1 https://segmentfault.com/u/yzwall
[2] blog.csdn.net/j_dark/

解题思路

LRU缓存两种功能:

  • get(key):获取key的对应value,不存在返回-1
  • set(key, value)(lintcode版本)/put(key, value)(leetcode版本):设置
    • 缓存已满,删除最近最久未被使用的节点,添加新节点进缓存
    • 缓存未满,
    • 节点存在,修改value;
    • 节点不存在,添加新节点进缓存;

解题思路

由于LRU缓存插入和删除操作频繁,使用双向链表维护缓存节点,
+ “新节点”:凡是被访问(新建/修改命中/访问命中)过的节点,一律在访问完成后移动到双向链表尾部保证链表尾部始终为最“新”节点
+ “旧节点”保证链表头部始终为最“旧”节点,LRU策略删除时表现为删除双向链表头部;
+ 从链表头部到尾部,节点访问热度逐渐递增

由于链表不支持随机访问,使用HashMap+双向链表实现LRU缓存;
+ HashMap中键值对:
+ 双向链表:维护缓存节点CacheNode

注意点

使用双向链表时,时刻记得维护prenext指针;

题目链接

  • lintcode 134: http://www.lintcode.com/zh-cn/problem/lru-cache/
  • leetcode 146: https://leetcode.com/problems/lru-cache/#/description

Java代码

/**
 * HashMap+双向链表实现LRU缓存
 * http://www.lintcode.com/zh-cn/problem/lru-cache/
 * https://leetcode.com/problems/lru-cache/#/description
 * @author yzwall
 */
import java.util.HashMap;

class Solution {
    private HashMap map;
    private int capacity;
    // head.next和tail.next指向链表头尾,包起来防止null
    private CacheNode head = new CacheNode(-1, -1);
    private CacheNode tail = new CacheNode(-1, -1);

    // 缓存节点
    private class CacheNode {
        int key, value;
        CacheNode pre, next;
        CacheNode(int key, int value) {
            this.key = key;
            this.value = value;
            this.pre = null;
            this.next = null;
        }
    }

    public Solution(int capacity) {
        this.map = new HashMap<>();
        this.capacity = capacity;
    }

    // 将已有节点或新建节点移动到链表尾部
    private void moveToTail(CacheNode target, boolean isNew) {
        // 尾部节点显然不需要移动
        if (target != tail.next) {
            if (!isNew) {
                // 修改旧节点的双向链表指针
                target.pre.next = target.next; 
                target.next.pre = target.pre;
            }
            // 添加节点到链表尾部
            tail.next.next = target;
            target.pre = tail.next;
            tail.next = target;
        }
    }

    // 命中节点添加到链表尾部,未命中返回-1
    public int get(int key) {
        if (map.containsKey(key)) {
            CacheNode target = map.get(key);
            // 将已有节点移动到链表尾部
            moveToTail(target, false);
            // 此时链表尾部tail.next = target,更新next指向null,防止出现环
            tail.next.next = null;
            return target.value;
        }
        return -1;
    }

    /**
     * 1. 节点命中,修改节点并移动到链表尾部tail.next
     * 2. 节点未命中,
     *    2.1 cache已满,删除链表头部head.next
     *    2.2 cache未满,新建节点并添加到链表尾部tail.next
     */
    public void set(int key, int value) {
        // cache中存在节点
        if (map.containsKey(key)) {
            CacheNode target = map.get(key);
            target.value = value;
            map.put(key, target);
            // 将访问过的已有节点移动到链表尾部
            moveToTail(target, false);
        } else if(map.size() < capacity) {  // cache未满,添加节点
            CacheNode newNode = new CacheNode(key, value);
            map.put(key, newNode);
            if (head.next == null) {
                head.next = newNode;
                newNode.pre = head;
                tail.next = newNode;
            } else {
                // 将新建节点移动到链表尾部
                moveToTail(newNode, true);
            }
        } else {    // cache已满,淘汰链表链表头部节点,新节点加入到链表尾部
            CacheNode newNode = new CacheNode(key, value);
            map.remove(head.next.key);
            map.put(key, newNode);
            // cache中只有一个元素
            if (head.next == tail.next) {
                head.next = newNode;
                tail.next = newNode;
            } else {    // cache中不止一个元素,删除头部
                head.next.next.pre = head; // 更新新头部.pre = head
                head.next = head.next.next;// 更新新头部
                // 将新建节点移动到链表尾部
                moveToTail(newNode, true);
            }
        }
    }
}

你可能感兴趣的:(高频面试算法题小结,算法,lintcode)