0
点赞
收藏
分享

微信扫一扫

MySQL各版本间差异以及需要注意的事项

1.leetcode原题链接:. - 力扣(LeetCode)

2.题目描述

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类:

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例:

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示:

  • 1 <= capacity <= 3000
  • 0 <= key <= 10000
  • 0 <= value <= 105
  • 最多调用 2 * 105 次 get 和 put

3.实现方法

思路:使用哈希加双向链表

1.定义一个Node类,用于存放数据

2.定义一个双向链表,里面存放Node

2.1 双向链表的构造

2.2 双向链表的方法1:把新节点添加到头中(addToHead)

2.3 双向链表的方法2:删除当前节点(removeNode)

2.4 双向链表的方法3:获取最后一个节点(getLast)

  return tail.prev

3.根据key从缓存获取value(get)

3.1当前key不存在,返回-1

3.2 其它,双向链表删除当前节点并添加到头节点,返回value

4.向缓存添加数据(put)

4.1 若存在当前key,替换value值并放回map中,双向链表删除当前节点并添加到头节点
4.2.1 容量满了,map和双向链表删除尾节点     

4.2.2 map放入要添加的Node,并把新Node放到双向链表的头节点

class LRUCache {

    //1.构建一个Node节点,存储数据
    class Node<K,V>{
        K key;
        V value;
        Node<K,V> next;
        Node<K,V> prev;

        public Node(){}

        public Node(K key,V value){
            this.key=key;
            this.value=value;
        }
    }

    //2 构建一个虚拟的双向链表,里面存放的是Node
    class DoubleLinkedList<K,V>{
        Node<K,V> head;
        Node<K,V> tail;

        //2.1 构造方法
        public DoubleLinkedList(){
            head=new Node();
            tail=new Node();
            head.next=tail;
            tail.prev=head;
        }

        //2.2 添加到头
        public void addToHead(Node<K,V> node){
            node.next=head.next;
            node.prev=head;
            head.next.prev=node;
            head.next=node;
        }

        //2.3 删除节点
        public void removeNode(Node<K,V> node){
            node.next.prev=node.prev;
            node.prev.next=node.next;
            node.next=null;
            node.prev=null;
        }

        //2.4 获取最后一个节点
        public Node getLast(){
            return tail.prev;
        }
    }


    private int capacity;
    Map<Integer,Node<Integer,Integer>> map;
    DoubleLinkedList<Integer,Integer> doubleLinkedList;


    public LRUCache(int capacity) {
        this.capacity=capacity;
        map=new HashMap();
        doubleLinkedList=new DoubleLinkedList();
    }
    
    public int get(int key) {
        // 当前key不存在,返回-1
        if(!map.containsKey(key)){
            return -1;
        }
        //其它,双向链表删除当前节点并添加到头节点,返回value
        Node<Integer,Integer> node=map.get(key);
        doubleLinkedList.removeNode(node);
        doubleLinkedList.addToHead(node);

        return node.value;
    }
    
    public void put(int key, int value) {
        //存在当前key,替换value值并放回map中
        //双向链表删除当前节点并添加到头节点
        if(map.containsKey(key)){
           Node<Integer,Integer> node= map.get(key);
           node.value=value;
           map.put(key,node);

           doubleLinkedList.removeNode(node);
           doubleLinkedList.addToHead(node);
        }else{
            //容量满了,map和双向链表删除尾节点
            if(map.size()== capacity){
                Node<Integer,Integer> node=doubleLinkedList.getLast();
                map.remove(node.key);
                doubleLinkedList.removeNode(node);

            }

            //map放入要添加的Node,并把新Node放到双向链表的头节点
            Node<Integer,Integer> newNode=new Node<>(key,value);
            map.put(key,newNode);
            doubleLinkedList.addToHead(newNode);
        }
    }
}
举报

相关推荐

0 条评论