LRU Cache (Least Recently Used)

Someshdiwan · Someshdiwan · commit a44219c84d3b · 2025-09-25T07:31:03.000+05:30
Signed-off-by: https://github.com/Someshdiwan <someshdiwan369@gmail.com>
diff --git a/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/ Cache and LRU Cache — Theory.txt b/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/ Cache and LRU Cache — Theory.txt
@@ -0,0 +1,117 @@
+Cache and LRU Cache — Theory
+
+1. What is Cache?
+-----------------
+- A **cache** is a temporary storage layer that stores frequently accessed data so it can be retrieved faster in the future.
+- Goal: **Reduce latency** (time to access data) and **improve performance** by avoiding repeated computation or slow I/O operations.
+
+💡 Examples of Cache:
+- Browser cache → stores images, CSS, JavaScript to load websites faster.
+- CPU cache → keeps recently used instructions/data closer to processor.
+- Database cache → stores query results for faster retrieval.
+
+---
+
+2. Why Caching is Needed?
+-------------------------
+- Accessing **RAM** is faster than accessing **Disk**.
+- Accessing **CPU cache (L1/L2)** is faster than **RAM**.
+- Cache reduces the gap between **fast components** (CPU) and **slow components** (Disk/Network).
+
+---
+
+3. What is LRU Cache?
+---------------------
+- **LRU = Least Recently Used**.
+- A cache replacement algorithm that decides which data to remove when the cache is full.
+- Idea:
+  - Keep the **most recently used** data in cache.
+  - Remove the **least recently used** data when new space is needed.
+
+---
+
+4. Origin and History
+---------------------
+- The concept of LRU was first studied in **paging and memory management research** in the 1960s–1970s.
+- It became popular in **operating systems (virtual memory)** to decide which memory page to replace when physical RAM was full.
+- Later adopted in **databases, web systems, and CPU design**.
+
+---
+
+5. Why Use LRU Cache?
+---------------------
+- Real-world workloads show **temporal locality**:
+  - If data is accessed now, it is likely to be accessed again soon.
+- LRU captures this principle: recently used = likely to be reused.
+- Helps balance **hit rate (cache effectiveness)** and **implementation simplicity**.
+
+---
+
+6. How LRU Works (Conceptual)
+------------------------------
+- Cache has limited size.
+- When new data is inserted:
+  - If not full → add it.
+  - If full → evict the **least recently accessed** item.
+- Recent accesses push data to the "top" of usage order.
+- Old, unused data is evicted.
+
+---
+
+7. Applications of LRU Cache
+-----------------------------
+
+### 🖥️ Computer Systems:
+- **CPU Caches (L1, L2, L3):**
+  - Store recently used instructions and data.
+- **Operating Systems (Paging):**
+  - When RAM is full, OS evicts least recently used memory pages.
+
+### 🌐 Web and Internet:
+- **Web Browsers:**
+  - Store recently visited pages, images, stylesheets.
+- **Content Delivery Networks (CDN):**
+  - Cache popular content closer to users.
+
+### 🗄️ Databases:
+- **Query Caching:**
+  - Store frequently executed SQL results.
+- **Index Caching:**
+  - Speed up database lookups.
+
+### 📱 Mobile Apps:
+- **In-app caches:**
+  - E.g., store profile pictures, news feed, or videos for quick reload.
+
+### 🚗 Real-World Analogies:
+- Your **wallet** acts like a cache:
+  - You keep frequently used items (cash, cards) handy.
+  - Rarely used items stay in a bigger "storage" (locker/bank).
+- **Refrigerator**:
+  - Keeps items you use often (milk, eggs) close at hand.
+  - Rarely used groceries go in a deep freezer (slower to access).
+
+---
+
+8. Advantages of LRU
+--------------------
+✔ Simple and intuitive.
+✔ Good performance for workloads with temporal locality.
+✔ Used widely in hardware and software systems.
+
+---
+
+9. Limitations of LRU
+---------------------
+❌ Not always optimal → fails for "sequential scans" (where every access is new).
+❌ Needs extra data structures (linked list, hashmap) to implement efficiently.
+❌ Can be memory intensive for large caches.
+
+---
+
+🔑 Summary
+----------
+- **Cache** = fast temporary storage for frequently used data.
+- **LRU Cache** = removes the least recently used item when full.
+- Foundational concept in **computer science, operating systems, and modern applications**.
+- Used everywhere → from **CPUs** to **web apps** to **mobile apps**.
diff --git a/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LRU Cache (Least Recently Used).txt b/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LRU Cache (Least Recently Used).txt
@@ -0,0 +1,121 @@
+LRU Cache (Least Recently Used)
+
+1. What is LRU Cache?
+---------------------
+- **LRU = Least Recently Used**.
+- It is a cache mechanism where:
+  - When the cache is **full** and a new item must be added,
+  - The **least recently accessed (used) item** is evicted (removed).
+- Ensures that **frequently used items stay in memory** while older, unused items are removed.
+
+Use cases:
+- Web browsers (back/forward pages cache).
+- Operating systems (page replacement algorithms).
+- Databases (query cache).
+- In-memory caches (like Redis or Guava Cache).
+
+---
+
+2. Core Principles
+------------------
+- Every time you **access (get/put)** an element:
+  - That element becomes the **most recently used (MRU)**.
+  - It is moved to the **end (tail)** of the internal list.
+- The **head** of the list always represents the **least recently used (LRU)** element.
+- On eviction → the head element is removed.
+
+---
+
+3. Internal Data Structures
+----------------------------
+Most implementations (like in Java using `LinkedHashMap`) use:
+
+- **HashMap**: For O(1) access (key → value lookup).
+- **Doubly Linked List**: To maintain the usage order (head = LRU, tail = MRU).
+
+So:
+- HashMap gives **fast access**.
+- Doubly Linked List gives **fast eviction/movement**.
+
+---
+
+4. ASCII Flow Example
+----------------------
+
+Capacity = 3
+
+```
+Start:   [ ]   (empty)
+```
+
+👉 Insert(1:A)
+```
+Order: 1:A
+```
+
+👉 Insert(2:B)
+```
+Order: 1:A → 2:B
+```
+
+👉 Insert(3:C)
+```
+Order: 1:A → 2:B → 3:C
+```
+
+👉 Access(1)
+```
+Move 1:A to end (MRU)
+Order: 2:B → 3:C → 1:A
+```
+
+👉 Insert(4:D) → Cache full → Evict eldest (2:B)
+```
+Order: 3:C → 1:A → 4:D
+```
+
+👉 Access(3)
+```
+Move 3:C to end
+Order: 1:A → 4:D → 3:C
+```
+
+👉 Insert(5:E) → Cache full → Evict eldest (1:A)
+```
+Order: 4:D → 3:C → 5:E
+```
+
+---
+
+5. ASCII Diagram of Structure
+------------------------------
+
+```
+HashMap (key → node reference):
+  1 → Node1
+  3 → Node3
+  5 → Node5
+
+Doubly Linked List (usage order):
+Head(LRU) → Node4:D ↔ Node3:C ↔ Node5:E ← Tail(MRU)
+```
+
+- **Head = LRU** (first to be removed).
+- **Tail = MRU** (recently accessed).
+
+---
+
+6. Why LRU is Efficient
+------------------------
+- **O(1)** lookup (thanks to HashMap).
+- **O(1)** update of usage order (thanks to doubly linked list).
+- Auto-evicts oldest entries when full → making it perfect for caches.
+
+---
+
+🔑 Recap
+--------
+- LRU Cache = Keep most recently used, evict least recently used.
+- Implemented using **HashMap + Doubly Linked List** (or `LinkedHashMap` in Java).
+- **Head → Oldest**, **Tail → Newest**.
+- Used heavily in caching systems, databases, and memory management.
diff --git a/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LinkedHashMap as an LRU Cache.txt b/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LinkedHashMap as an LRU Cache.txt
@@ -0,0 +1,124 @@
+LinkedHashMap as an LRU Cache
+
+1. Background
+-------------
+- **LinkedHashMap** is a subclass of `HashMap` that maintains **insertion order** or **access order**.
+- By default, it keeps keys in the order they were inserted.
+- But if you enable `accessOrder = true`, the map will reorder entries every time they are accessed (get/put).
+- This behavior makes it ideal to implement an **LRU (Least Recently Used) Cache**.
+
+---
+
+2. The Two Key Ingredients
+--------------------------
+
+### (a) Access Order
+- Constructor of LinkedHashMap has this signature:
+
+```java
+LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
+```
+
+- If `accessOrder = true`:
+  - Every time you call `get(key)` or `put(key, value)`, that entry is **moved to the end** of the linked list.
+  - The "eldest" entry (least recently accessed) stays at the **front**.
+
+---
+
+### (b) removeEldestEntry()
+- LinkedHashMap provides a method you can override:
+
+```java
+protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
+```
+
+- By default → always returns `false` (no auto-removal).
+- But if you override it to return `true` when size exceeds capacity, the **oldest (least recently used)** entry is automatically removed.
+
+---
+
+3. How LRU Works with LinkedHashMap
+-----------------------------------
+
+Imagine a cache with capacity = 3, accessOrder = true:
+
+```
+Put(A) → [A]
+Put(B) → [A, B]
+Put(C) → [A, B, C]
+Get(A) → moves A to end → [B, C, A]
+Put(D) → capacity exceeded → eldest B removed → [C, A, D]
+```
+
+👉 The **eldest (front)** is always the least recently used.
+
+---
+
+4. ASCII Flow Diagram
+----------------------
+
+### Initial State:
+```
+[ A ] → [ B ] → [ C ]   (accessOrder = true)
+Front (eldest)         End (most recent)
+```
+
+### After get(A):
+```
+[ B ] → [ C ] → [ A ]
+```
+
+### After put(D) (capacity 3):
+```
+[ C ] → [ A ] → [ D ]
+(B removed as eldest)
+```
+
+---
+
+5. Why is This Essentially an LRU Cache?
+----------------------------------------
+- LRU = "remove the least recently used item when adding new items beyond capacity."
+- LinkedHashMap does this automatically:
+  1. **Tracks recency of use** with `accessOrder = true`.
+  2. **Evicts oldest** entry using overridden `removeEldestEntry()`.
+
+---
+
+6. Typical Example (LRU using LinkedHashMap)
+--------------------------------------------
+
+```java
+class LRUCache<K, V> extends LinkedHashMap<K, V> {
+    private final int capacity;
+
+    public LRUCache(int capacity) {
+        super(capacity, 0.75f, true); // accessOrder = true
+        this.capacity = capacity;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
+        return size() > capacity; // remove eldest if size exceeds capacity
+    }
+}
+```
+
+👉 This class is a **ready-to-use LRU Cache**.
+
+---
+
+7. Real-world Applications
+--------------------------
+- Browser tab history (least recently opened tab closed first).
+- Database query caching.
+- File system caches.
+- Memory-sensitive caches in web servers and frameworks.
+
+---
+
+🔑 Summary
+----------
+- **LinkedHashMap + accessOrder = true** = maintains recency of access.
+- **removeEldestEntry()** = automatically removes least recently used.
+- Together, they provide a **built-in, easy LRU Cache implementation** without needing custom data structures.
diff --git a/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LinkedHashMap vs LinkedHashMap as LRU Cache.txt b/Section 25 Collections Frameworks/Map Interface/Linked HashMap/LRU Cache/LRU Cache (Least Recently Used)/LinkedHashMap vs LinkedHashMap as LRU Cache.txt
@@ -0,0 +1,21 @@
+📊 LinkedHashMap vs LinkedHashMap as LRU Cache
+==============================================
+
+| Feature                        | Plain LinkedHashMap                            | LinkedHashMap as LRU Cache                        |
+|--------------------------------|------------------------------------------------|--------------------------------------------------|
+| **Ordering Mode**              | Insertion order by default                     | Access order (`accessOrder = true`)              |
+| **Reordering on Access**       | ❌ No reordering (keys stay in inserted order)  | ✅ Keys move to the end when accessed/updated     |
+| **Eviction Policy**             | ❌ None (entries remain until removed manually) | ✅ `removeEldestEntry()` can evict least recent   |
+| **removeEldestEntry()**        | Default → always `false`                       | Overridden → returns `true` if size > capacity   |
+| **Use Case**                   | When you just need predictable iteration order | When you need an **LRU cache**                   |
+| **Example Behavior**           | Put(A), Put(B), Put(C) → [A, B, C]             | Put(A), Put(B), Put(C), Get(A), Put(D) → [C, A, D] |
+| **Memory Management**          | No auto-cleanup                                | Oldest (least recently used) entries auto-removed|
+| **Performance**                | O(1) for get/put                               | O(1) for get/put + eviction check (still O(1))   |
+
+---
+
+✅ **Key Insight:**
+- **Plain LinkedHashMap** = maintains *insertion order*.
+- **LinkedHashMap with `accessOrder=true` + `removeEldestEntry()`** = behaves like an **LRU Cache**.
+
+👉 That’s why **LinkedHashMap is the backbone of many Java cache implementations**.
