146. LRU 缓存机制 + 哈希表 + 自定义双向链表

146. LRU 缓存机制

LeetCode-146

题目描述

题解分析

java代码

package com.walegarrett.interview;

/**
 * @Author WaleGarrett
 * @Date 2021/2/19 8:51
 */

import java.util.HashMap;
import java.util.Map;

/**
 * 题目描述：运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制 。
 * 实现 LRUCache 类：
 *      LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
 *      int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
 *      void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。
 *                                   当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
 *  
 * 进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？
 */
public class LeetCode_146 {
    private DLinkedNode head,tail;//伪头结点和尾结点
    private int size,capacity;
    private Map<Integer,DLinkedNode> map = new HashMap<>();
    public LeetCode_146(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        //创建伪头结点和伪尾结点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.pre = head;
    }

    public int get(int key) {
        DLinkedNode node = map.get(key);
        if(node == null)
            return -1;
        //如果key存在，因为这是最新使用的将其移动到头结点
        removeToHead(node);
        return node.value;
    }

    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存在，首先更新哈希表中的value
            node.value = value;
            map.put(key, node);
            //该结点为最近访问的结点，添加到头结点
            removeToHead(node);
        }
    }
    /**
     * 双向链表的自定义实现
     */
    class DLinkedNode{
        int key,value;
        DLinkedNode pre,next;
        public DLinkedNode(){}
        public DLinkedNode(int _key, int _value){key = _key; value=_value;}
    }

    /**
     * 将新结点放置到头结点
     * @param node
     */
    private void addToHead(DLinkedNode node){
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
    }

    /**
     * 移除当前结点
     * @param node
     */
    private void removeNode(DLinkedNode node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    /**
     * 将当前结点移动到头结点
     * @param node
     */
    private void removeToHead(DLinkedNode node){
        removeNode(node);
        addToHead(node);
    }

    /**
     * 删除尾结点
     */
    private DLinkedNode removeTail(){
        DLinkedNode realTail = tail.pre;
        removeNode(realTail);
        return realTail;
    }
}

复杂度分析