LFU Cache - Practice Coding Problems

LFU Cache - Problem

Design and implement a Least Frequently Used (LFU) Cache - one of the most challenging cache eviction policies used in real-world systems!

Your task is to create an LFUCache class that efficiently manages data with limited capacity. When the cache is full and you need to insert a new item, you must evict the least frequently used key. If there's a tie in frequency, evict the least recently used among them.

Key Operations:
• LFUCache(capacity): Initialize the cache with given capacity
• get(key): Return the value if key exists, otherwise -1. This counts as a use!
• put(key, value): Insert or update the key-value pair. This also counts as a use!

The Challenge: Both operations must run in O(1) average time - no linear searches allowed! This requires a sophisticated combination of hash tables and doubly-linked lists to track both frequency and recency efficiently.

Real-world application: Operating systems use LFU caching for memory management, CDNs use it for content delivery, and databases use it for buffer pool management.

Input & Output

example_1.py — Basic LFU Operations

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

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

💡 Note: Cache capacity is 2. put(1,1), put(2,2), get(1) returns 1 and increases freq of key 1. put(3,3) evicts key 2 (freq 1, older than key 1). get(2) returns -1 (evicted). get(3) returns 3. put(4,4) evicts key 1 (freq 2 vs key 3 freq 2, but key 1 is older). Final cache contains keys 3 and 4.

example_2.py — Frequency Tie-Breaking

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

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

💡 Note: Capacity 2: put(3,1), put(2,1) evicts key 3, put(2,2) updates key 2, put(4,4) adds key 4. After gets, both keys have freq 2, but when put(5,5) needs space, key 3 is evicted as it's older among freq-2 keys.

example_3.py — Capacity 1 Edge Case

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

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

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) lookup, doubly-linked list provides O(1) insertion/deletion, frequency buckets provide O(1) LFU access

✓ Linear Growth

Space Complexity

O(capacity)

Hash map + doubly-linked list nodes + frequency buckets, all proportional to capacity

✓ Linear Space

Constraints

0 ≤ capacity ≤ 10⁴
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

The optimal LFU Cache solution combines hash tables for O(1) key lookup with frequency buckets containing doubly-linked lists for O(1) eviction. Each frequency level maintains its own LRU order, while tracking the minimum frequency enables instant access to the least frequently used items. This sophisticated architecture achieves O(1) time complexity for both get() and put() operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(capacity)	Use simple hash map with linear search to find LFU item
Optimal: Hash Table + Frequency Buckets + Doubly-Linked Lists	O(1)	O(capacity)	Use hash maps with frequency buckets containing doubly-linked lists for O(1) operations

Brute Force (Linear Search) — Algorithm Steps

Store each item with its value, frequency, and timestamp
For get(): lookup in hash map, increment frequency, update timestamp
For put(): if key exists, update and increment frequency
If capacity exceeded, scan all items to find minimum frequency
Among items with min frequency, find the oldest timestamp
Remove the selected item and insert the new one

Visualization

Tap to expand

Step-by-Step Walkthrough

Cache State

Current items with their frequencies

Linear Search

Scan all items to find minimum frequency

Eviction

Remove LFU item and add new item

Code -

solution.c — C

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

typedef struct {
    int key;
    int value;
    int freq;
    int time;
} Node;

typedef struct {
    Node* nodes;
    int capacity;
    int size;
    int time;
} LFUCache;

LFUCache* lFUCacheCreate(int capacity) {
    LFUCache* cache = (LFUCache*)malloc(sizeof(LFUCache));
    cache->nodes = (Node*)malloc(sizeof(Node) * capacity);
    cache->capacity = capacity;
    cache->size = 0;
    cache->time = 0;
    return cache;
}

int lFUCacheGet(LFUCache* obj, int key) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->nodes[i].key == key) {
            obj->nodes[i].freq++;
            obj->nodes[i].time = obj->time++;
            return obj->nodes[i].value;
        }
    }
    return -1;
}

void lFUCachePut(LFUCache* obj, int key, int value) {
    if (obj->capacity <= 0) return;
    
    // Check if key exists
    for (int i = 0; i < obj->size; i++) {
        if (obj->nodes[i].key == key) {
            obj->nodes[i].value = value;
            obj->nodes[i].freq++;
            obj->nodes[i].time = obj->time++;
            return;
        }
    }
    
    // Need to add new key
    if (obj->size >= obj->capacity) {
        // Find LFU node
        int lfuIndex = 0;
        for (int i = 1; i < obj->size; i++) {
            if (obj->nodes[i].freq < obj->nodes[lfuIndex].freq ||
               (obj->nodes[i].freq == obj->nodes[lfuIndex].freq && 
                obj->nodes[i].time < obj->nodes[lfuIndex].time)) {
                lfuIndex = i;
            }
        }
        // Remove LFU node by shifting
        for (int i = lfuIndex; i < obj->size - 1; i++) {
            obj->nodes[i] = obj->nodes[i + 1];
        }
        obj->size--;
    }
    
    // Add new node
    obj->nodes[obj->size].key = key;
    obj->nodes[obj->size].value = value;
    obj->nodes[obj->size].freq = 1;
    obj->nodes[obj->size].time = obj->time++;
    obj->size++;
}

void lFUCacheFree(LFUCache* obj) {
    free(obj->nodes);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each put() operation may require scanning all n items to find the LFU item

✓ Linear Growth

Space Complexity

O(capacity)

Hash map stores at most 'capacity' number of items

✓ Linear Space

Constraints

0 ≤ capacity ≤ 10⁴
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

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler