手写一个hashmap/ LRU

public class MyHashMap<K, V> {
    private Entry[] table;
    private static Integer CAPACITY = 8;
    private int size = 0;

    public MyHashMap() {
        this.table = new Entry[CAPACITY];
    }

    public int size() {
        return size;
    }

    public V get(K key) {
        int hash = key.hashCode();
        int i = hash % CAPACITY;

        for (Entry<K, V> entry = table[i]; entry != null; entry = entry.next) {
            if (key.equals(entry.k)){
                return entry.v;
            }
        }
        return null;
    }

    public V put(K key, V value) {

        int hash = key.hashCode();
        int i = hash % CAPACITY;

        for (Entry<K, V> entry = table[i]; entry != null; entry = entry.next) {
            if (entry.k.equals(key)) {
                V oldValue = entry.v;
                entry.v = value;
                return oldValue;
            }
        }

        addEntry(key, value, i);
        size++;
        return null;
    }

    private void addEntry(K key, V value, int i) {
        //增加节点
        Entry<K, V> entry = new Entry<>(key, value, table[i]);
        table[i] = entry;
    }

    class Entry<K, V> {
        private K k;
        private V v;
        private Entry<K, V> next;

        public Entry(K k, V v, Entry<K, V> next) {
            this.k = k;
            this.v = v;
            this.next = next;
        }

        public K getK() {
            return k;
        }

        public V getV() {
            return v;
        }

        public Entry<K, V> getNext() {
            return next;
        }
    }

    public static void main(String[] args) {
        MyHashMap<String,String> hashMap = new MyHashMap<>();
        for (int i = 0; i < 10; i++) {
            hashMap.put("key"+i,"value"+i);
        }
        String s = hashMap.get("key");
        System.out.println(s);
    }

}



class Solution {
public:
    /**
     * lru design
     * @param operators int整型vector<vector<>> the ops
     * @param k int整型 the k
     * @return int整型vector
     */
    int k;
    struct Node{
        long long  key,val;
        Node *left,*right;
        Node(long long _key,long long _val): key(_key),val(_val),left(NULL),right(NULL){}
    }*L,*R;
    unordered_map<long long, Node *> hash;
    void remove(Node *p){
        p->right->left=p->left;
        p->left->right=p->right;
    }
    void insert(Node *p){
        p->right=L->right;
        p->left=L;
        L->right->left=p;
        L->right=p;
    }
    long long get(long long key){
        if(hash.count(key)==0) return -1;
        auto p=hash[key];
        remove(p);
        insert(p);
        return p->val;
    }
    void set(long long key,long long value){
        if(hash.count(key)){
            auto p=hash[key];
            p->val=value;
            remove(p);
            insert(p);
        }else{
            if(hash.size()==k){
                auto p=R->left;
                remove(p);
                hash.erase(p->key);
                delete(p);
            }
            auto p=new Node(key,value);
            insert(p);
            hash[key]=p;
        }
         
    }
    vector<int> LRU(vector<vector<int> >& operators, int _k) {
        k=_k;
        L=new Node(-1,-1),R=new Node(-1,-1);
        L->right=R,R->left=L;
        vector<int> ans;
        for(auto x:operators){
            if(x[0]==1) set(x[1],x[2]);
            if(x[0]==2) ans.push_back(get(x[1]));
        }
        return ans;
    }
     
};