How can I implement LFU caching in my application?

How can I implement LFU caching in my application?

To implement LFU (Least Frequently Used) caching, you can use a combination of a hash map and a priority queue. The hash map stores the key-value pairs, while the priority queue keeps track of the frequency of access.

Can you provide a code example for that?

Sure! Here's a simple Python implementation:

class LFUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}  # key -> (value, frequency)
        self.freq = {}  # frequency -> keys
        self.min_freq = 0

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        value, freq = self.cache[key]
        self.cache[key] = (value, freq + 1)
        self.freq[freq].remove(key)
        if not self.freq[freq]:
            del self.freq[freq]
            if self.min_freq == freq:
                self.min_freq += 1
        self.freq.setdefault(freq + 1, []).append(key)
        return value

    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0:
            return
        if key in self.cache:
            self.cache[key] = (value, self.cache[key][1])
            self.get(key)  # Update frequency
            return
        if len(self.cache) >= self.capacity:
            lfu_key = self.freq[self.min_freq][0]
            del self.cache[lfu_key]
            self.freq[self.min_freq].pop(0)
            if not self.freq[self.min_freq]:
                del self.freq[self.min_freq]
        self.cache[key] = (value, 1)
        self.freq.setdefault(1, []).append(key)
        self.min_freq = 1

What are the advantages of using LFU caching?

LFU caching is beneficial because it efficiently manages memory by keeping frequently accessed items in cache, reducing the number of cache misses and improving performance for read-heavy workloads.