What are some examples of LRU cache implementations?

What are some examples of LRU cache implementations?

LRU (Least Recently Used) cache is a popular caching algorithm. Here are a few examples of its implementation:

1. Python: Using collections.OrderedDict to maintain the order of access.
2. Java: Using LinkedHashMap to create an LRU cache.
3. C++: Implementing with a combination of std::list and std::unordered_map.

Can you show me a Python example?

Sure! Here's a simple Python implementation using OrderedDict:

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        else:
            self.cache.move_to_end(key)
            return self.cache[key]

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

What about a Java example?

Here's a Java example using LinkedHashMap:

import java.util.LinkedHashMap;
import java.util.Map;

class LRUCache extends LinkedHashMap<Integer, Integer> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }
}