LeetCode设计实现题

Posted 2022-10-08 fonxian

一、LRU缓存机制(LeetCode-146)

1.1 题目描述

1.2 解题思路

思路1：

使用Map存放key，value，使用List存放key和count，count为最新的index值，每次put、get操作都会使index自增。

进行put操作时，如果发现超过容量值capacity，则对list中的count排序，map和list都删除掉index最小的元素。（提示超时）

思路2：

使用LinkedList，每次put操作或get操作，当list中没有该key的元素的时候，且不超过容量时，直接插入元素，若有则删除key对应的原有元素，插入key对应的新元素值。

如果超过容量，则删除第一个元素，再添加进去。（通过）

1.3 解题代码

思路1：

public class LRUCache 

    private Map<Integer, Integer> map = null;
    private List<HitCount> list = null;
    private Map<Integer, HitCount> locationMap = null;
    private int index = 0;
    private int capacity = 0;


    public LRUCache(int capacity) 
        map = new HashMap<>(capacity);
        list = new LinkedList<>();
        locationMap = new HashMap<>(capacity);
        this.capacity = capacity;
    

    public int get(int key) 
        //先找到key-value
        Integer value = map.get(key);
        if (value == null) 
            return -1;
        

        HitCount h = locationMap.get(key);
        h.setCount(++index);
        return value;
    

    public void put(int key, int value) 
        //若key已存在
        Integer existValue = map.get(key);
        //容量不充足
        if (existValue == null && map.size() == capacity) 
            //找到命中次数最少的一个、若命中次数相同，则去除插入最早的
            HitCount leastKey = getLeastKey();
            map.remove(leastKey.getKey());
            list.remove(leastKey);
            locationMap.remove(leastKey.getKey());
        
        HitCount h = null;
        if (existValue != null) 
            h = locationMap.get(key);
            h.setCount(++index);
         else 
            h = new HitCount(key, ++index);
            list.add(h);
        
        map.put(key, value);
        locationMap.put(key, h);
        index++;
    


    private HitCount getLeastKey() 
        list = list.stream().sorted((u1, u2) -> (u1.getCount() - u2.getCount())).collect(Collectors.toList());
        return list.get(0);
    


    class HitCount 
        private int key;
        private int count;

        HitCount(int key, int count) 
            this.key = key;
            this.count = count;
        

        public int getKey() 
            return key;
        

        public void setKey(int key) 
            this.key = key;
        

        public int getCount() 
            return count;
        

        public void setCount(int count) 
            this.count = count;
        

    

思路2：

public class LRUCache 

    private List<LRUMap> list = null;
    private int capacity = 0;

    public LRUCache(int capacity) 
        list = new LinkedList<>();
        this.capacity = capacity;
    

    public int get(int key) 
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) 
            LRUMap node = (LRUMap) iterator.next();
            if (node.getKey() == key) 
                int value = node.getValue();
                list.remove(node);
                list.add(new LRUMap(key, value));
                return value;
            
        
        return -1;
    

    public void put(int key, int value) 
        LRUMap node = new LRUMap(key, value);

        //查看该节点是否存在
        if (list.contains(node)) 
            list.remove(node);
        
        //如果超过容量
        if (list.size() == capacity) 
            list.remove(0);
        
        list.add(node);

    

    class LRUMap 

        private int key;
        private int value;

        public LRUMap(int key, int value) 
            this.key = key;
            this.value = value;
        

        public int getKey() 
            return key;
        

        public void setKey(int key) 
            this.key = key;
        

        public int getValue() 
            return value;
        

        public void setValue(int value) 
            this.value = value;
        

        @Override
        public boolean equals(Object obj) 
            if (obj == this) 
                return true;
            
            if (obj == null || obj.getClass() != this.getClass()) 
                return false;
            

            LRUMap map = (LRUMap) obj;
            return key == map.key;