力扣 - 146. LRU緩存機制

目錄

• 題目
• 思路
  • 代碼
  • 複雜度分析

題目

146. LRU緩存機制

思路

• 利用雙鏈表和HashMap來解題
• 看到鏈表題目，咱們能夠使用頭尾結點能夠更好進行鏈表操做和邊界判斷等
• 還須要使用size變量來存儲雙鏈表的當前長度
• 調用get，若是存在的話，咱們能夠調用將在雙鏈表中的結點經過修改指針移動到第一個；若是調用put，咱們先判斷是否存在該結點，若是不存在，可直接將連接插入便可，同時size++，若是存在的話，先刪除原來的結點，再將新結點push到頭部便可

代碼

class LRUCache {
    class Node {
        int key;
        int val;
        Node pre;
        Node next;

        public Node() {}

        public Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }

    // 哈希表中的node和雙鏈表的node是同一個結點
    private HashMap<Integer, Node> cache;
    private Node dummyHead;
    private Node dummyTail;
    private int size;
    private int capacity;

    public LRUCache(int capacity) {
        cache = new HashMap<>();
        dummyHead = new Node();
        dummyTail = new Node();
        dummyHead.next = dummyTail;
        dummyTail.pre = dummyHead;
        this.capacity = capacity;
        this.size = 0;
    }
    
    public int get(int key) {
        // 先獲取看看結點存不存在
        Node node = cache.get(key);
        // 若是存在的話，將當前訪問的結點移動到鏈表頭，而且返回值
        if (node != null) {
            moveToHead(node);
            return node.val;
        }
        // 不存在的話就返回-1
        return -1;
    }
    
    public void put(int key, int value) {
        // 也是先看看結點是否存在
        Node node = cache.get(key);
        // 若是存在，那麼要作的操做就是將結點移動到鏈表頭，而後更新結點值便可
        if (node != null) {
            node.val = value;
            moveToHead(node);
        } else {
            // 若是不存在的話咱們就要建立新結點插入
            Node newNode = new Node(key, value);
            // 先添加到哈希表中
            cache.put(key, newNode);
            // 再添加到鏈表中
            addToHead(newNode);
            // 而且長度+1
            size++;
            // 由於咱們設定最大容量，咱們還要判斷新put的結點後，容量是否超過了capacity，超過了話，刪除最後一個結點，而且長度-1
            if (size > capacity) {
                Node tail = removeTail();
                cache.remove(tail.key);
                size--;
            }
        }
    }

    /**
    * 將node移動到最前面
    */
    private void moveToHead(Node node) {
        if (size > 0 && size <= capacity) {
            remove(node);
            addToHead(node);
        }
    }

    /**
    * 刪除node結點
    */
    private void remove(Node node) {
        if (size > 0) {
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
    }

    /**
    * 刪除最後一個結點
    */
    private Node removeTail() {
        if (size > 0) {
            Node node = dummyTail.pre;
            remove(node);
            return node;
        }
        return null;
    }

    /**
    * 添加新結點到第一位去
    */
    private void addToHead(Node node) {
        node.next = dummyHead.next;
        dummyHead.next = node;
        node.next.pre = node;
        node.pre = dummyHead;
    }
}

複雜度分析

• 時間複雜度：\(O(1)\)
• 空間複雜度：\(O(N)\)，其中 N 爲初始化的 capacity 容量