Sword finger offer special assault edition day 10

The finger of the sword Offer II 030. Insert 、 Deletion and random access are O(1) The container of

Variable length array （ Random access ）+ Hashtable （$O(1)$ increase 、 Delete ）

class RandomizedSet {
    
private:
    unordered_map<int,int> um;
    vector<int> nums;
public:
    unordered_set<int> us;
    /** Initialize your data structure here. */
    RandomizedSet() {
    
        srand((unsigned)time(nullptr));
    }
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    bool insert(int val) {
    
        if(um.count(val)) return false;
        nums.push_back(val);
        um[val] = nums.size()-1;
        return true;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    bool remove(int val) {
    
        if(!um.count(val)) return false;
        int idx = um[val];
        nums[idx] = nums.back();
        um[nums.back()] = idx;
        nums.pop_back();
        um.erase(val);
        return true;
    }
    
    /** Get a random element from the set. */
    int getRandom() {
    
        return nums[rand()%nums.size()];
    }
};

---

The finger of the sword Offer II 031. At least use cache recently

Double linked list + Hashtable
Have use （get、put） Add the node of to the head node , If the capacity is not enough, just delete the tail node

class LRUCache {
    
private:
    struct DLinkedNode {
    
        int key,value;
        DLinkedNode *next, *prev;
    }*head, *tail;
    unordered_map<int,DLinkedNode*> um;
    int capacity;    
public:
    LRUCache(int capacity) {
    
        this->capacity = capacity;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
    
        if(um.count(key)) {
    
            move_to_head(um[key]);
            return um[key]->value;
        } else {
    
            return -1;
        }
    }
    
    void put(int key, int value) {
    
        if(um.count(key)) {
    
            um[key]->value = value;
            move_to_head(um[key]);
        } else {
    
            DLinkedNode *node = new DLinkedNode();
            node->value = value;
            node->key = key;
            add_to_head(node);
            um[key]= node;
            if(um.size() > capacity) {
    
                um.erase(tail->prev->key);
                delete remove_node(tail->prev); // Prevent memory overflow 
            }
        }
    }

    void add_to_head(DLinkedNode *node) {
    
        node->next = head->next;
        node->prev = head;
        head->next->prev = node;
        head->next = node;
    }

    void move_to_head(DLinkedNode *node) {
    
        remove_node(node);
        add_to_head(node);
    }

    DLinkedNode* remove_node(DLinkedNode *node){
    
        node->prev->next = node->next;
        node->next->prev = node->prev;
        return node;
    }

};