LeetCode: LRU Cache

看别人的答案：

struct CacheNode {
    int key, value;
    CacheNode(int a, int b) : key(a), value(b) { }
};
class LRUCache{
public:
    LRUCache(int capacity) {
        size = capacity;
    }
    
    int get(int key) {
        if (cacheMap.find(key) == cacheMap.end()) return -1;
        else {
            cachelist.splice(cachelist.begin(), cachelist, cacheMap[key]);
            cacheMap[key] = cachelist.begin();
            return cacheMap[key]->value;
        }
    }
    
    void set(int key, int value) {
        if (cacheMap.find(key) == cacheMap.end()) {
            if (cachelist.size() == size) {
                cacheMap.erase(cachelist.back().key);
                cachelist.pop_back();
            }
            cachelist.push_front(CacheNode(key, value));
            cacheMap[key] = cachelist.begin();
        }
        else {
            cacheMap[key]->value = value;
            cachelist.splice(cachelist.begin(), cachelist, cacheMap[key]);
            cacheMap[key] = cachelist.begin();
        }
    }
    
private:
    list<CacheNode> cachelist;
    unordered_map<int, list<CacheNode>::iterator> cacheMap;
    int size;
};

 自己写了另一段更容易懂的代码：

struct node {
    int key;
    int val;
    node* next;
    node(int k, int v) : key(k), val(v), next(NULL) { }
};
class LRUCache{
public:
    LRUCache(int capacity) {
        len = capacity;
    }
    
    int get(int key) {
        if (!head) return -1;
        if (head->key == key) return head->val;
        node* p = head;
        int cur = 1;
        while (p->next && cur < len) {
            cur++;
            if (p->next->key == key) {
                node* q = p->next;;
                p->next = p->next->next;
                q->next = head;
                head = q;
                return head->val;
            }
            p = p->next;
        }
        return -1;
    }
    
    void set(int key, int value) {
        if (!head) head = new node(key, value);
        else {
            node* p = new node(key, value);
            p->next = head;
            head = p;
            int cur = 1;
            while (p->next && cur < len) {
                cur++;
                if (p->next->key == key) {
                    p->next = p->next->next;
                    break;
                }
                p = p->next;
            }
        }
    }
private:
    node* head = NULL;
    int len;
};

 C#

public class node {
    public int key;
    public int val;
    public node next;
    public node(int k, int v) {
        key = k;
        val = v;
        next = null;
    }
};
public class LRUCache {

    public LRUCache(int capacity) {
        head = null;
        len = capacity;
    }

    public int Get(int key) {
        if (head == null) return -1;
        if (head.key == key) return head.val;
        node p = head;
        int cur = 1;
        while (p.next != null && cur < len) {
            cur++;
            if (p.next.key == key) {
                node q = p.next;
                p.next = p.next.next;
                q.next = head;
                head = q;
                return head.val;
            }
            p = p.next;
        }
        return -1;
    }

    public void Set(int key, int value) {
        if (head == null) head = new node(key, value);
        else {
            node p = new node(key, value);
            p.next = head;
            head = p;
            int cur = 1;
            while (p.next != null && cur < len) {
                cur++;
                if (p.next.key == key) {
                    p.next = p.next.next;
                    break;
                }
                p = p.next;
            }
        }
    }
    node head;
    int len;
}