Implemented using double link list

Runtime: 104 ms, faster than 90.83% of C++ online submissions for LRU Cache.
Memory Usage: 37.6 MB, less than 93.90% of C++ online submissions for LRU Cache.

Author: c0D3M

lru.cpp

@@ -1,23 +1,65 @@
 class LRUCache {
-    unordered_map<int, int> hash;
-    list<int> lru;
-    int n;
-public:
-    void findAndDelete(int key)
+    
+    typedef struct node
     {
-            // Find the key in list and delete
-            for (auto it = lru.begin(); it != lru.end(); ++it) 
-            {
-                //cout <<*it<<"\n";
-                if(*it==key)
-                {
-                    lru.erase(it);
-                    break;
-                }
-            }
+        int key;
+        int value;
+        struct node *prev;
+        struct node *next;
+    }N;
+    unordered_map<int, N*> hash;
+    N *pool;
+    N *front; //head of list
+    N *back;
+    
+    void insert(N* node, int key, int value)
+    {
+        //Insert at front of link list
+        node->key = key;
+        node->value =value;
+        node->prev = NULL;
+        node->next = front;
+        if(front)
+            front->prev = node;
+        front = node;
+        if(!back) // when list is empty
+            back = front;
+        hash[key] = node;//Insert in hash table
+    }
+    void update(N *n, int value)
+    {
+        n->value = value; // update the valie
+        if(n==front) // if update the front node, no processing required
+            return;
+        // re-wire
+        if(n->prev)
+            n->prev->next = n->next;
+        if(n->next)
+            n->next->prev = n->prev;
+        else//Back pointer is updated when the back node is accessed
+            back = n->prev;// update back pointer
+        
+        //Move to top
+        n->next = front;
+        n->prev = NULL;
+        front->prev = n;
+        front = n;
+    }
+    void remove()
+    {
+        N * node = back->prev;
+        if(node)
+            node->next = NULL;
+        back = node;
     }
+    int n;
+    int size;
+public:
     LRUCache(int capacity) {
         n = capacity;
+        size = 0;
+        pool = new N[n];
+        front = back = NULL;
     }
 
     int get(int key) {
@@ -26,35 +68,31 @@ class LRUCache {
             return -1;
         else
         {
-            findAndDelete(key);
-            //and move to front
-            lru.push_front(key);
-            
-            return hash[key];
+            update(hash[key], hash[key]->value);
+            return hash[key]->value;
         }
-            
-        
     }
 
-    void put(int key, int value) {
+    void put(int key, int value) 
+    {
+        //cout<< value<<"\n";
+        N *node;
         //If existing key is geting inserted
         if(hash.find(key)!=hash.end()) //key present
-            findAndDelete(key);
-        
-        if(hash.find(key)==hash.end())
+            update(hash[key], value);
+        else
         {
             if(hash.size()==n)
             {
-                // Find tail item from LRU list.
-                int indx = lru.back();
-                lru.pop_back();
-                hash.erase(indx);    
+                
+                node = back;
+                hash.erase(back->key);// Remove the entry from  hash table
+                remove(); //Remove the back node from LRU List
             }
-        }
-        
+            else
+                node = &pool[size++];
 
-        hash[key] = value;
-        //insert in LRU List;
-        lru.push_front(key);        
+            insert(node, key, value);
+        }
     }
 };