LRU算法实现

题目描述

题目描述
设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能

• set(key, value)：将记录(key, value)插入该结构
• get(key)：返回key对应的value值

[要求]

1. set和get方法的时间复杂度为O(1)
2. 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
3. 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。

若opt=1，接下来两个整数x, y，表示set(x, y)
若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
对于每个操作2，输出一个答案

题目背景

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

他在我们有频繁需要访问的内容时比较常用，因为频繁的访问数据库不太现实，所以计划将内容储存进内存中，通过设置储存量大小来控制内存中能够访问的数据量。

题目思路

我们创建一种哈希链表，每一个键值对与其他键值对彼此联系，形成一双向链表，让键值对拥有前驱与后继，通过从一头插入，另一头删除的模式解决问题。

代码与运行结果

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

public class LinkedHashMapTest {

    public static void main(String[] args) {
        int[][] operators = {{1,1,1},{1,2,2},{1,3,2},{2,1},{1,4,4},{2,2}};
        int k = 3;
        int[] res = doLru(operators,k);

        System.out.print("最终输出的数组： " + Arrays.toString(res));
    }

    public static int[] doLru(int[][] operators, int k) {
        LRU<Integer,Integer> LRUcache = new LRU<>(k);

        int count = 0;

        for(int i = 0;i<operators.length;i++){
            if(operators[i][0] == 2){
                count++;
            }
        }

        int[] res = new int[count];
        int num = 0;
        for(int i = 0;i<operators.length;i++){
       		System.out.println("第" + (i+1) + "次循环");
            if(operators[i][0] == 1){
                LRUcache.set(operators[i][1],operators[i][2]);
                
            }else if(operators[i][0] == 2){
                if(Objects.isNull(LRUcache.get(operators[i][1]))){
                    res[num] = -1;
                }else{
                    res[num] = LRUcache.get(operators[i][1]);
                }
                num++;
                

            }
        }

        return res;

    }




}

//LRU结构
class LRU<K, V> {
    public int cap;//储存量

    public int maxCap;//最大储存量

    public Map<K,Node<K,V>> table = new HashMap<>();//记录Node的表

    public Node<K,V> head;
    public Node<K,V> tail;

    public LRU(int maxCap){
        head = new Node<>();
        tail = new Node<>();
        head.next = tail;
        head.prev = null;
        tail.prev = head;
        tail.next = null;
        this.maxCap = maxCap;
    }

    public void set(Object k,Object v){
        if(cap == maxCap){
            //删除最后一个节点再加入节点
            Node<K,V> deletedNode = tail.prev;
            table.remove(deletedNode.key);

            deletedNode.prev.next = tail;
            tail.prev = deletedNode.prev;

            add(k,v);

        }else if(table.containsKey(k)){
            Node<K,V> temp = table.get(k);
            temp.value = (V) v;

            temp.next.prev = temp.prev;
            temp.prev.next = temp.next;

            temp.next = head.next.next;
            head.next = temp;
            temp.next.prev = temp;
            temp.prev = head;


            table.replace((K) k,temp);

        }else{
            add(k,v);

            cap++;
        }

        System.out.println("table = " + table.toString());
        System.out.println("head.next = " + head.next.toString());
        System.out.println("tail.prev = " + tail.prev.toString());
        System.out.println("=====================");


    }

//在头部加入一个新的节点
    public void add(Object k,Object v){
        Node<K,V> nodeTemp = new Node<>();
        nodeTemp.key = (K) k;
        nodeTemp.value = (V) v;

        nodeTemp.next = head.next;
        head.next = nodeTemp;
        nodeTemp.next.prev = nodeTemp;
        nodeTemp.prev = head;

        table.put(nodeTemp.key,nodeTemp);
    }

    public V get(Object k){
        if(table.containsKey(k)){
            Node<K,V> temp = table.get(k);

            temp.prev.next = temp.next;
            temp.next.prev = temp.prev;

            temp.next = head.next;
            head.next.prev = temp;
            head.next = temp;
            temp.prev = head;

            System.out.println("table = " + table.toString());
            System.out.println("head.next = " + head.next.toString());
            System.out.println("tail.prev = " + tail.prev.toString());
            System.out.println("=====================");
            return table.get(k).value;
        }else {
            System.out.println("table = " + table.toString());
            System.out.println("head.next = " + head.next.toString());
            System.out.println("tail.prev = " + tail.prev.toString());
            System.out.println("=====================");
            return null;
        }
    }
}

//建造键值对的类
class Node<K,V>{
    public K key;
    public V value;
    public Node<K,V> prev;
    public Node<K,V> next;

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

    }

    @Override
    public String toString() {
        return "(" + key + "," + value + ")";
    }
}

运行结果图：

一张放不下,下面是第二张。

Java提供了一种LinkedHashmap类似于这个功能，有兴趣可以去瞄一眼。