[Leetcode] LRU 算法实现

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

LRU是虚拟内存技术中，页置换时需要用到的算法，最近最少使用算法。也就是说替换掉最近最少被使用的页。

采用双链表实现一个栈，栈顶(用head指针表示)放最近使用的元素。end指针表示栈底，地方不够的时候end指针的元素值就会被覆盖，覆盖后因为成了最近使用，所以会被提到head的位置。链表中部也可能有元素被提到head的位置。

class LRUCache{

struct ListNode{

    int key;

    int value;

    ListNode* prev;

    ListNode* next;

};

public:

    LRUCache(int capacity){

        if(capacity >= ){

            Capacity = capacity;

            size = ;

        }

    }

    void set(int key, int value){

        ListNode* p = head;

        for(; p != NULL && p -> key != key; p = p -> next);

        if(p == NULL && size == Capacity){  //The case that didn't find key and capacity is full

            p = end;

            p -> key = key;

        }

        if(p != NULL){  //The case that has found the key (treat the previous case as found the key in end)

            p -> value = value;

            if(p != head){  //If the key is in head of the list, we don't need to do anything since the head is the most recently used.

                ListNode* pre = p -> prev;

                ListNode* fol = p -> next;

                if(p == end && pre != NULL){

                    end = pre;

                }

                p -> next = head;

                p -> prev = NULL;

                head -> prev = p;

                head = p;

                if(pre != NULL)

                    pre -> next = fol;

                if(fol != NULL)

                    fol -> prev = pre;

            }

        }else{  //The case that has not found the key, and capacity is not full, need to create one.

            p = new ListNode();

            p -> key = key;

            p -> value = value;

            if(head == NULL){

                head = end = p;

                p -> prev = NULL;

                p -> next = NULL;

            }else{

                p -> prev = NULL;

                p -> next = head;

                head -> prev = p;

                head = p;

            }

            size++;

        }

    }

    int get(int key){

        ListNode* p = head;

        for(; p != NULL && p -> key != key; p = p -> next);

        if(p == NULL) return -;

        if(p != head){

            ListNode* pre = p -> prev;

            ListNode* fol = p -> next;

            if(p == end)

                end = pre;

            p -> next = head;

            p -> prev = NULL;

            head -> prev = p;

            head = p;

            if(pre != NULL)

                pre -> next = fol;

            if(fol != NULL)

                fol -> prev = pre;

        }

        return p -> value;

    }

private:

    ListNode* head = NULL;

    ListNode* end = NULL;

    int size = ;

    int Capacity = ;

};

巴特西

[Leetcode] LRU 算法实现

最新文章

热门文章