docs(baguwen): 新增 LRU 和 LFU 每日一问

Author: LeoninCS

content/docs/baguwen/每日一问.md

@@ -7,6 +7,219 @@ weight: 8
 
 记录微信交流群中每天的提问。
 
+## 2026.06.09
+
+### LRU 和 LFU 是什么？适用于什么场景，底层的实现原理是什么？
+
+评级：LRU 手撕高频，LFU 可能会被提及
+
+1. LRU 是 Least Recently Used，按最近访问时间淘汰数据。核心思想是时间局部性：最近访问过的数据，短期内再次访问概率更高。缓存容量满时，优先淘汰最久没有被访问的数据。
+2. LFU 是 Least Frequently Used，按访问频次淘汰数据。核心思想是稳定热点：访问次数越高的数据，未来继续被访问的概率更高。缓存容量满时，优先淘汰访问次数最低的数据。
+3. LRU 适合热点变化快、最近访问更能代表未来访问的场景，比如页面缓存、本地查询结果缓存、操作系统页缓存、InnoDB Buffer Pool 类缓存。
+4. LFU 适合长期热点明显、访问频次稳定、希望降低偶发访问干扰的场景，比如 Redis 热点 Key、CDN 静态资源缓存、商品详情缓存、推荐特征缓存。
+5. LRU 的底层实现通常是哈希表 + 双向链表。哈希表负责通过 key 在 O(1) 时间定位节点；双向链表负责维护访问顺序，链表头部放最近访问的数据，链表尾部放最久访问的数据。`Get` 命中后把节点移动到头部，`Put` 命中后更新值并移动到头部，容量满时删除尾部节点。
+6. LFU 的底层实现通常是 `key -> node` 哈希表 + `freq -> 双向链表` 哈希表 + `minFreq`。每个节点记录 key、value、freq；同一访问频次的节点放在同一条双向链表里，链表内部再按 LRU 顺序排列。`Get` 命中后频次加一，把节点从旧频次链表移动到新频次链表；`Put` 容量满时，从 `minFreq` 对应链表的尾部淘汰一个节点。
+7. 工程取舍：LRU 实现简单、维护成本低，对最近访问敏感；LFU 更能保留长期高频热点，但频次统计有额外维护成本，热点迁移时会受历史频次影响，生产实现常加入频次衰减或近似统计。
+8. 面试收口：LRU 看最近一次访问时间，核心结构是 `map + 双向链表`；LFU 看访问次数，核心结构是 `map + freqMap + minFreq + 双向链表`。手写重点是保证 `Get`、`Put`、移动节点和淘汰节点都是 O(1)。
+
+#### LRU 示例代码
+
+```go
+package main
+
+import "fmt"
+
+type lruNode struct {
+	key, value int
+	prev, next *lruNode
+}
+
+type LRUCache struct {
+	capacity int
+	items    map[int]*lruNode
+	head     *lruNode
+	tail     *lruNode
+}
+
+func NewLRUCache(capacity int) *LRUCache {
+	head, tail := &lruNode{}, &lruNode{}
+	head.next = tail
+	tail.prev = head
+
+	return &LRUCache{
+		capacity: capacity,
+		items:    make(map[int]*lruNode),
+		head:     head,
+		tail:     tail,
+	}
+}
+
+func (c *LRUCache) Get(key int) int {
+	node, ok := c.items[key]
+	if !ok {
+		return -1
+	}
+	c.moveToHead(node)
+	return node.value
+}
+
+func (c *LRUCache) Put(key, value int) {
+	if c.capacity <= 0 {
+		return
+	}
+
+	if node, ok := c.items[key]; ok {
+		node.value = value
+		c.moveToHead(node)
+		return
+	}
+
+	node := &lruNode{key: key, value: value}
+	c.items[key] = node
+	c.addToHead(node)
+
+	if len(c.items) > c.capacity {
+		removed := c.removeTail()
+		delete(c.items, removed.key)
+	}
+}
+
+func (c *LRUCache) moveToHead(node *lruNode) {
+	c.remove(node)
+	c.addToHead(node)
+}
+
+func (c *LRUCache) addToHead(node *lruNode) {
+	node.prev = c.head
+	node.next = c.head.next
+	c.head.next.prev = node
+	c.head.next = node
+}
+
+func (c *LRUCache) remove(node *lruNode) {
+	node.prev.next = node.next
+	node.next.prev = node.prev
+}
+
+func (c *LRUCache) removeTail() *lruNode {
+	node := c.tail.prev
+	c.remove(node)
+	return node
+}
+
+func main() {
+	cache := NewLRUCache(2)
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+	fmt.Println(cache.Get(1)) // 1
+	cache.Put(3, 3)
+	fmt.Println(cache.Get(2)) // -1，key 2 被淘汰
+}
+```
+
+#### LFU 示例代码
+
+```go
+package main
+
+import (
+	"container/list"
+	"fmt"
+)
+
+type lfuEntry struct {
+	key, value int
+	freq       int
+}
+
+type LFUCache struct {
+	capacity int
+	size     int
+	minFreq  int
+	items    map[int]*list.Element
+	freqs    map[int]*list.List
+}
+
+func NewLFUCache(capacity int) *LFUCache {
+	return &LFUCache{
+		capacity: capacity,
+		items:    make(map[int]*list.Element),
+		freqs:    make(map[int]*list.List),
+	}
+}
+
+func (c *LFUCache) Get(key int) int {
+	element, ok := c.items[key]
+	if !ok {
+		return -1
+	}
+
+	entry := element.Value.(*lfuEntry)
+	c.increaseFreq(element)
+	return entry.value
+}
+
+func (c *LFUCache) Put(key, value int) {
+	if c.capacity <= 0 {
+		return
+	}
+
+	if element, ok := c.items[key]; ok {
+		entry := element.Value.(*lfuEntry)
+		entry.value = value
+		c.increaseFreq(element)
+		return
+	}
+
+	if c.size == c.capacity {
+		listByFreq := c.freqs[c.minFreq]
+		back := listByFreq.Back()
+		entry := back.Value.(*lfuEntry)
+		delete(c.items, entry.key)
+		listByFreq.Remove(back)
+		c.size--
+	}
+
+	entry := &lfuEntry{key: key, value: value, freq: 1}
+	listByFreq := c.getList(1)
+	c.items[key] = listByFreq.PushFront(entry)
+	c.minFreq = 1
+	c.size++
+}
+
+func (c *LFUCache) increaseFreq(element *list.Element) {
+	entry := element.Value.(*lfuEntry)
+	oldFreq := entry.freq
+	oldList := c.freqs[oldFreq]
+	oldList.Remove(element)
+
+	if oldFreq == c.minFreq && oldList.Len() == 0 {
+		c.minFreq++
+	}
+
+	entry.freq++
+	newList := c.getList(entry.freq)
+	c.items[entry.key] = newList.PushFront(entry)
+}
+
+func (c *LFUCache) getList(freq int) *list.List {
+	if c.freqs[freq] == nil {
+		c.freqs[freq] = list.New()
+	}
+	return c.freqs[freq]
+}
+
+func main() {
+	cache := NewLFUCache(2)
+	cache.Put(1, 1)
+	cache.Put(2, 2)
+	fmt.Println(cache.Get(1)) // 1，key 1 的频次变成 2
+	cache.Put(3, 3)
+	fmt.Println(cache.Get(2)) // -1，key 2 频次最低，被淘汰
+	fmt.Println(cache.Get(3)) // 3
+}
+```
+
 ## 2026.06.08
 
 ### 短视频平台点赞系统高并发设计