LRU算法

https://blog.csdn.net/luoweifu/article/details/8297084

参考上方博主的思路，使用双向链表和hashMap来实现，但是觉得hashMap来回改，效率也没提升多少吧

整个输入以及过程可以参考上方博主给的思路，理解了！

如输入以下序列时：4,7,0,7,1,0,1,2,1,2,6

结果为：

4        
4        7        
4        7        0        
4        0        7        
4        0        7        1        
4        7        1        0        
4        7        0        1        
4        7        0        1        2        
4        7        0        2        1        
4        7        0        1        2        
7        0        1        2        6        

import java.util.HashMap;
import java.util.LinkedList;

public class LRU {
    public static void main(String[] args) {
        LRU lru = new LRU();
        int[] item=new int[]{4,7,0,7,1,0,1,2,1,2,6};
        for (int i = 0; i < item.length; i++) {
            lru.push(item[i]);
        }
        lru.showList();
    }
    //容量
    private int N=5;

    //存放数组
    private LinkedList<Object> lists=new LinkedList<>();
    private HashMap<Object,Integer> hashMap=new HashMap<>();

    private boolean isFull(){
        return lists.size()>=N;
    }

    //返回插入位置索引
    public int push(Object obj){
        if(hashMap.containsKey(obj)){
            int index=hashMap.get(obj);//找到这个key的索引
            for(int i=index;i<lists.size()-1;i++){
                lists.set(i,lists.get(i+1));
                hashMap.put(lists.get(i),hashMap.get(lists.get(i))-1);
            }
            lists.set(lists.size()-1,obj);
            hashMap.put(obj,lists.size()-1);
        }
        else {
            if(!isFull()){
                hashMap.put(obj,lists.size());//放入索引，因为要在现在的list上追加，索引为lists.size()-1+1
                lists.add(obj);
            }
            else {
                Object first=lists.getFirst();
                hashMap.remove(first);
                lists.removeFirst();
                lists.add(obj);
                for (int i = 0; i < lists.size(); i++) {
                    hashMap.put(lists.get(i),i);
                }
            }
        }
        return hashMap.get(obj);
    }

    public void showList(){
        for (int i = 0; i < lists.size(); i++) {
            System.out.print(lists.get(i)+" ");
        }
    }
}

 //第二次写，这次不使用hashMap，因为调整它的性能感觉比使用它还要高：

package test.suanfa;

import java.util.HashMap;
import java.util.LinkedList;

public class LRU {
    public static void main(String[] args) {
        test.test.LRU lru = new test.test.LRU();
        int[] item=new int[]{4,7,0,7,1,0,1,2,1,2,6};
        for (int i = 0; i < item.length; i++) {
            lru.push(item[i]);
        }
        lru.showList();
    }
    //capcity
    private int N=5;
    //curCapcity 其实我使用 list.size()也可以
    private int size=0;
    //存放 【对象->索引】（不用了，因为一旦某一个变化hash内部后面的全部需要变化，也没省性能，反而占空间）
    HashMap<Object,Integer> hashMap;
    //对象存在队列中
    private LinkedList list;

    public LRU(){
        list=new LinkedList();
        hashMap=new HashMap<>();
    }

    private void push(Object obj){
        if(size<5){
            int index=-1;
            for(int i=0;i<size;i++){
                if(list.get(i).equals(obj)){
                    index=i;
                    break;
                }
            }
            //判断是否存在
            if(index==-1){
                list.add(obj);
                size++;
            }
            else {
                for(int i=index;i<size-1;i++){
                    list.set(i,list.get(i+1));
                }
                list.set(size-1,obj);
            }
        }
        else {
            list.removeFirst();
            list.add(obj);
        }
    }
    public void showList(){
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
    }
}