LRU Cache - Practice Coding Problems

LRU Cache - Problem

Design and implement a Least Recently Used (LRU) Cache data structure that efficiently manages a limited amount of storage space by automatically evicting the least recently accessed items when capacity is exceeded.

Your LRUCache class should support:

LRUCache(int capacity): Initialize the cache with a positive capacity
int get(int key): Return the value associated with the key if it exists, otherwise return -1. This operation marks the key as recently used.
void put(int key, int value): Insert or update the key-value pair. If adding this pair exceeds capacity, remove the least recently used key first. This operation marks the key as recently used.

Challenge: Both get and put operations must run in O(1) average time complexity.

Example:

LRUCache cache = new LRUCache(2);
cache.put(1, 1);  // cache: {1=1}
cache.put(2, 2);  // cache: {1=1, 2=2}
cache.get(1);     // returns 1, cache: {2=2, 1=1}
cache.put(3, 3);  // evicts key 2, cache: {1=1, 3=3}
cache.get(2);     // returns -1 (not found)

Input & Output

example_1.py — Basic Operations

$ Input: ["LRUCache","put","put","get","put","get","put","get","get","get"] [[2],[1,1],[2,2],[1],[3,3],[2],[4,4],[1],[3],[4]]

› Output: [null,null,null,1,null,-1,null,-1,3,4]

💡 Note: LRUCache cache = new LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1) returns 1; cache.put(3, 3) evicts key 2; cache.get(2) returns -1 (not found); cache.put(4, 4) evicts key 1; cache.get(1) returns -1, cache.get(3) returns 3, cache.get(4) returns 4

example_2.py — Single Capacity

$ Input: ["LRUCache","put","get","put","get","get"] [[1],[2,1],[2],[3,2],[2],[3]]

› Output: [null,null,1,null,-1,2]

💡 Note: With capacity 1: put(2,1), get(2) returns 1, put(3,2) evicts key 2, get(2) returns -1, get(3) returns 2

example_3.py — Update Existing Key

$ Input: ["LRUCache","put","put","put","put","get","get"] [[2],[1,1],[2,2],[1,10],[2,20],[1],[2]]

› Output: [null,null,null,null,null,10,20]

💡 Note: Updating existing keys should not trigger eviction, just update values and move to most recent position

Visualization

Tap to expand

Understanding the Visualization

Initialize Cache

Set up empty hash map and linked list with dummy head/tail nodes

First Access

Add new entries at the head (most recent position)

Subsequent Access

Move accessed items to head, maintaining recency order

Capacity Exceeded

Remove tail node (least recently used) and add new item at head

Key Takeaway

🎯 Key Insight: The combination of hash map (O(1) lookup) and doubly-linked list (O(1) insertion/deletion with known node) creates the perfect data structure for LRU cache requirements.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) lookup, doubly-linked list provides O(1) insertion/deletion with known node reference

✓ Linear Growth

Space Complexity

O(capacity)

Hash map stores at most capacity entries, doubly-linked list stores at most capacity nodes

✓ Linear Space

Constraints

1 ≤ capacity ≤ 3000
0 ≤ key ≤ 10⁴
0 ≤ value ≤ 10⁵
At most 2 × 10⁴ calls will be made to get and put
Both operations must run in O(1) average time complexity

Asked in

G Google 75 a Amazon 68 f Meta 52 ⊞ Microsoft 41

The optimal solution uses a hash map combined with a doubly-linked list to achieve O(1) time complexity for both get and put operations. The hash map provides instant key lookup, while the doubly-linked list maintains the order of usage, allowing constant-time insertion, deletion, and reordering of elements.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + Doubly Linked List (Optimal)	O(1)	O(capacity)	Combine hash map for O(1) lookup with doubly linked list for O(1) insertion/deletion
Array-Based Cache with Linear Search	O(n)	O(capacity)	Use an array to store key-value pairs and search linearly for operations

Hash Map + Doubly Linked List (Optimal) — Algorithm Steps

Create a doubly-linked list with dummy head and tail nodes
Use a hash map to store key -> list node mappings
For get(key): if found in hash map, move node to head and return value
For put(key, value): if key exists, update and move to head
If new key and capacity exceeded, remove tail node and its hash entry
Add new node at head and update hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Hash map with dummy head and tail nodes connected

Adding Elements

New nodes added after head, hash map updated

Access Operation

Hash lookup finds node, moves to head position

Eviction

Remove tail node, update hash map

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int key, value;
    struct Node* prev;
    struct Node* next;
} Node;

typedef struct {
    int capacity;
    int size;
    Node** hashTable;
    int hashSize;
    Node* head;
    Node* tail;
} LRUCache;

int hash(int key, int size) {
    return (key % size + size) % size;
}

Node* createNode(int key, int value) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->key = key;
    node->value = value;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

void addNode(LRUCache* obj, Node* node) {
    node->prev = obj->head;
    node->next = obj->head->next;
    
    obj->head->next->prev = node;
    obj->head->next = node;
}

void removeNode(Node* node) {
    Node* prevNode = node->prev;
    Node* nextNode = node->next;
    
    prevNode->next = nextNode;
    nextNode->prev = prevNode;
}

void moveToHead(LRUCache* obj, Node* node) {
    removeNode(node);
    addNode(obj, node);
}

Node* popTail(LRUCache* obj) {
    Node* lastNode = obj->tail->prev;
    removeNode(lastNode);
    return lastNode;
}

LRUCache* lRUCacheCreate(int capacity) {
    LRUCache* obj = (LRUCache*)malloc(sizeof(LRUCache));
    obj->capacity = capacity;
    obj->size = 0;
    obj->hashSize = capacity * 2;
    obj->hashTable = (Node**)calloc(obj->hashSize, sizeof(Node*));
    
    obj->head = createNode(0, 0);
    obj->tail = createNode(0, 0);
    obj->head->next = obj->tail;
    obj->tail->prev = obj->head;
    
    return obj;
}

int lRUCacheGet(LRUCache* obj, int key) {
    int index = hash(key, obj->hashSize);
    Node* node = obj->hashTable[index];
    
    while (node && node->key != key) {
        node = node->next;
    }
    
    if (node) {
        moveToHead(obj, node);
        return node->value;
    }
    
    return -1;
}

void lRUCachePut(LRUCache* obj, int key, int value) {
    int index = hash(key, obj->hashSize);
    Node* node = obj->hashTable[index];
    
    while (node && node->key != key) {
        node = node->next;
    }
    
    if (node) {
        node->value = value;
        moveToHead(obj, node);
    } else {
        Node* newNode = createNode(key, value);
        
        if (obj->size >= obj->capacity) {
            Node* tail = popTail(obj);
            int tailIndex = hash(tail->key, obj->hashSize);
            
            // Remove from hash table
            if (obj->hashTable[tailIndex] == tail) {
                obj->hashTable[tailIndex] = NULL;
            }
            free(tail);
            obj->size--;
        }
        
        obj->hashTable[index] = newNode;
        addNode(obj, newNode);
        obj->size++;
    }
}

void lRUCacheFree(LRUCache* obj) {
    free(obj->hashTable);
    free(obj->head);
    free(obj->tail);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) lookup, doubly-linked list provides O(1) insertion/deletion with known node reference

✓ Linear Growth

Space Complexity

O(capacity)

Hash map stores at most capacity entries, doubly-linked list stores at most capacity nodes

✓ Linear Space

Constraints

1 ≤ capacity ≤ 3000
0 ≤ key ≤ 10⁴
0 ≤ value ≤ 10⁵
At most 2 × 10⁴ calls will be made to get and put
Both operations must run in O(1) average time complexity

125.5K Views

Very High Frequency

~35 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map + Doubly Linked List (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler