LRU Cache

LRU Cache - Problem

Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.

Implement the LRUCache class:

LRUCache(int capacity) - Initialize the LRU cache with positive size capacity
int get(int key) - Return the value of the key if the key exists, otherwise return -1
void put(int key, int value) - Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.

The functions get and put must each run in O(1) average time complexity.

Input & Output

Example 1 — Basic LRU Operations

$ Input: capacity = 2, operations = [["put",1,1],["put",2,2],["get",1],["put",3,3],["get",2],["put",4,4],["get",1],["get",3],["get",4]]

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

💡 Note: Cache capacity is 2. put(1,1), put(2,2) fills cache. get(1) returns 1. put(3,3) evicts key 2. get(2) returns -1 (evicted). put(4,4) evicts key 1. get(1) returns -1, get(3) returns 3, get(4) returns 4.

Example 2 — Single Capacity

$ Input: capacity = 1, operations = [["put",2,1],["get",2],["put",3,2],["get",2],["get",3]]

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

💡 Note: With capacity 1, each put operation evicts the previous key. put(2,1), get(2) returns 1, put(3,2) evicts key 2, get(2) returns -1, get(3) returns 2.

Example 3 — Update Existing Key

$ Input: capacity = 2, operations = [["put",1,1],["put",2,2],["put",1,10],["get",1],["get",2]]

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

💡 Note: put(1,1), put(2,2), then put(1,10) updates existing key 1 to value 10 and moves it to most recent. get(1) returns 10, get(2) returns 2.

Constraints

1 ≤ capacity ≤ 3000
0 ≤ key ≤ 10⁴
0 ≤ value ≤ 10⁵
At most 2 × 10⁴ calls will be made to get and put

Visualization

Tap to expand

Asked in

G Google 85 A Amazon 72 M Microsoft 68 F Facebook 61 🍎 Apple 45

The key insight is combining a hash map for O(1) key lookup with a doubly linked list for O(1) insertion/deletion to maintain LRU order. The optimal approach uses hash map + doubly linked list achieving O(1) time complexity for both get and put operations with O(capacity) space.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force with Array

⏱️ Time: O(n) Space: O(capacity)

Store cache entries in an array and maintain access order. For get/put operations, search through array linearly. Move accessed items to front and remove from back when capacity exceeded.

Hash Map + Doubly Linked List

⏱️ Time: O(1) Space: O(capacity)

Use a hash map to store key-to-node mappings for O(1) access. Maintain a doubly linked list where head is most recent and tail is least recent. This allows O(1) operations for both access and LRU eviction.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Simple max heap implementation
typedef struct {
    int* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createMaxHeap(int capacity) {
    MaxHeap* heap = (MaxHeap*)malloc(sizeof(MaxHeap));
    heap->data = (int*)malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MaxHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[idx] <= heap->data[parent]) break;
        
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[parent];
        heap->data[parent] = temp;
        
        idx = parent;
    }
}

void heapifyDown(MaxHeap* heap, int idx) {
    while (1) {
        int largest = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && heap->data[left] > heap->data[largest])
            largest = left;
        if (right < heap->size && heap->data[right] > heap->data[largest])
            largest = right;
        
        if (largest == idx) break;
        
        int temp = heap->data[idx];
        heap->data[idx] = heap->data[largest];
        heap->data[largest] = temp;
        
        idx = largest;
    }
}

void push(MaxHeap* heap, int val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MaxHeap* heap) {
    int max = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return max;
}

int solution(int* nums, int len, int k) {
    MaxHeap* maxHeap = createMaxHeap(len + k);
    
    // Build initial heap
    for (int i = 0; i < len; i++) {
        push(maxHeap, nums[i]);
    }
    
    int totalScore = 0;
    
    for (int i = 0; i < k; i++) {
        int maxVal = pop(maxHeap);
        totalScore += maxVal;
        
        int newVal = (int)ceil(maxVal / 3.0);
        push(maxHeap, newVal);
    }
    
    free(maxHeap->data);
    free(maxHeap);
    return totalScore;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int len = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            nums[len++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, len, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

982.0K Views

Very High Frequency

~35 min Avg. Time

15.4K 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