通过Golang的container/list实现LRU缓存算法

席万里2025-03-09 18:35

文章目录

    • [力扣：146. LRU 缓存](#力扣：146. LRU 缓存)
    • [主要结构 List 和 Element](#主要结构 List 和 Element)
      • 常用方法
      • [1. 初始化链表](#1. 初始化链表)
      • [2. 插入元素](#2. 插入元素)
      • [3. 删除元素](#3. 删除元素)
      • [4. 遍历链表](#4. 遍历链表)
      • [5. 获取链表长度](#5. 获取链表长度)
      • 使用场景
      • 注意事项
    • 源代码阅读

在 Go 语言中，container/list 包提供了一个双向链表的实现。链表是一种常见的数据结构，适用于频繁插入和删除操作的场景。container/list 包中的链表是双向的，意味着每个元素都包含指向前一个和后一个元素的指针。

力扣：146. LRU 缓存

力扣算法链接：https://leetcode.cn/problems/lru-cache/?envType=study-plan-v2&envId=top-100-liked

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存。

int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。

void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

输入

"LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"

\[2\], \[1, 1\], \[2, 2\], \[1\], \[3, 3\], \[2\], \[4, 4\], \[1\], \[3\], \[4\]

输出

null, null, null, 1, null, -1, null, -1, 3, 4

解释

LRUCache lRUCache = new LRUCache(2);

lRUCache.put(1, 1); // 缓存是 {1=1}

lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}

lRUCache.get(1); // 返回 1

lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}

lRUCache.get(2); // 返回 -1 (未找到)

lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}

lRUCache.get(1); // 返回 -1 (未找到)

lRUCache.get(3); // 返回 3

lRUCache.get(4); // 返回 4

代码案例：

go 复制代码 
type Node struct {
	key   int
	value int
}

type LRUCache struct {
	capacity int
	list     *list.List
	mp       map[int]*list.Element
}

func Constructor(capacity int) LRUCache {
	return LRUCache{
		capacity: capacity,
		list:     list.New(),
		mp:       make(map[int]*list.Element),
	}
}

func (this *LRUCache) Get(key int) int {
	if v, ok := this.mp[key]; ok {
		this.list.MoveToFront(v)
		return v.Value.(*Node).value
	}
	return -1
}

func (this *LRUCache) Put(key int, value int) {
	if v, ok := this.mp[key]; ok {
		v.Value.(*Node).value = value
		this.list.MoveToFront(v)
        return
	}
	node := &Node{key, value}
	a := this.list.PushFront(node)
	this.mp[key] = a

	if this.list.Len() > this.capacity {
		tmp := this.list.Back()
		delete(this.mp, tmp.Value.(*Node).key)
		this.list.Remove(tmp)
	}
}

主要结构 List 和 Element

  • List: 表示一个双向链表。
go 复制代码 
type List struct {
	root Element // sentinel list element, only &root, root.prev, and root.next are used
	len  int     // current list length excluding (this) sentinel element
}
  • Element: 表示链表中的一个元素。
go 复制代码 
type Element struct {
	next, prev *Element
	list *List
	Value any
}

常用方法

1. 初始化链表

使用 list.New() 创建一个新的链表。

go 复制代码 
func main() {
	l := list.New()

	fmt.Printf("%+v\n",l)
}

2. 插入元素

  • PushBack(value interface{}) *Element: 在链表尾部插入一个元素。
  • PushFront(value interface{}) *Element: 在链表头部插入一个元素。
  • InsertBefore(value interface{}, mark *Element) *Element: 在指定元素前插入一个元素。
  • InsertAfter(value interface{}, mark *Element) *Element: 在指定元素后插入一个元素。
go 复制代码 
func main() {
	l := list.New()

	l.PushBack(123)
	l.PushBack("nihao")
	l.PushFront("你好")
	l.PushFront(3.1415926)

	// 遍历
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Printf("%+v\n", e)
	}
}

通过运行结果可以发现，list其实就是一个环形的双向链表。

3. 删除元素

  • Remove(e *Element) interface{}: 删除链表中的指定元素。
go 复制代码 
func main() {
	l := list.New()

	l.PushBack("nihao")

	a:=l.Remove(l.Back())
	fmt.Println(a)
}

4. 遍历链表

  • Front() *Element: 返回链表的第一个元素。
  • Back() *Element: 返回链表的最后一个元素。
  • Next() *Element: 返回当前元素的下一个元素。
  • Prev() *Element: 返回当前元素的前一个元素。
go 复制代码 
func main() {
    l := list.New()

    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)

    // 从前往后遍历
    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Println(e.Value)
    }

    // 从后往前遍历
    for e := l.Back(); e != nil; e = e.Prev() {
        fmt.Println(e.Value)
    }
}

5. 获取链表长度

  • Len() int: 返回链表中元素的个数。
go 复制代码 
func main() {
    l := list.New()

    l.PushBack(1)
    l.PushBack(2)
    l.PushBack(3)

    fmt.Println(l.Len()) // 输出: 3
}

使用场景

  • 频繁插入和删除: 链表在插入和删除操作上比数组更高效，尤其是在中间位置。
  • 实现队列和栈: 链表可以用来实现队列（FIFO）和栈（LIFO）等数据结构。
  • 动态数据存储: 当数据量不确定或需要动态调整时，链表是一个很好的选择。

注意事项

  • 内存开销: 链表的每个元素都需要额外的内存来存储前后指针，因此内存开销比数组大。
  • 随机访问性能差: 链表不支持随机访问，访问某个元素需要从头或尾开始遍历。

源代码阅读

go 复制代码 
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package list implements a doubly linked list.
//
// To iterate over a list (where l is a *List):
//
//	for e := l.Front(); e != nil; e = e.Next() {
//		// do something with e.Value
//	}
package list

// Element is an element of a linked list.
type Element struct {
	//双链表元素中的下一个和上一个指针。
	//为了简化实现，在内部实现了列表l
	//作为一个环，这样&l.root既是最后一个元素的下一个元素
	//list元素（l.Back（））和第一个列表的前一个元素
	//元素（l.Front（））。
	next, prev *Element

	// The list to which this element belongs.
	list *List

	// The value stored with this element.
	Value any
}

// Next returns the next list element or nil.
func (e *Element) Next() *Element {
	if p := e.next; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

// Prev returns the previous list element or nil.
func (e *Element) Prev() *Element {
	if p := e.prev; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List struct {
	root Element // sentinel list element, only &root, root.prev, and root.next are used
	len  int     // current list length excluding (this) sentinel element
}

// Init initializes or clears list l.
func (l *List) Init() *List {
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0
	return l
}

// New returns an initialized list.
func New() *List { return new(List).Init() }

// Len returns the number of elements of list l.
// The complexity is O(1).
func (l *List) Len() int { return l.len }

// Front returns the first element of list l or nil if the list is empty.
func (l *List) Front() *Element {
	if l.len == 0 {
		return nil
	}
	return l.root.next
}

// Back returns the last element of list l or nil if the list is empty.
func (l *List) Back() *Element {
	if l.len == 0 {
		return nil
	}
	return l.root.prev
}

// lazyInit lazily initializes a zero List value.
func (l *List) lazyInit() {
	if l.root.next == nil {
		l.Init()
	}
}

// insert inserts e after at, increments l.len, and returns e.
func (l *List) insert(e, at *Element) *Element {
	e.prev = at
	e.next = at.next
	e.prev.next = e
	e.next.prev = e
	e.list = l
	l.len++
	return e
}

// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
func (l *List) insertValue(v any, at *Element) *Element {
	return l.insert(&Element{Value: v}, at)
}

// remove removes e from its list, decrements l.len
func (l *List) remove(e *Element) {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next = nil // avoid memory leaks
	e.prev = nil // avoid memory leaks
	e.list = nil
	l.len--
}

// move moves e to next to at.
func (l *List) move(e, at *Element) {
	if e == at {
		return
	}
	e.prev.next = e.next
	e.next.prev = e.prev

	e.prev = at
	e.next = at.next
	e.prev.next = e
	e.next.prev = e
}

// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
// The element must not be nil.
func (l *List) Remove(e *Element) any {
	if e.list == l {
		// if e.list == l, l must have been initialized when e was inserted
		// in l or l == nil (e is a zero Element) and l.remove will crash
		l.remove(e)
	}
	return e.Value
}

// PushFront inserts a new element e with value v at the front of list l and returns e.
func (l *List) PushFront(v any) *Element {
	l.lazyInit()
	return l.insertValue(v, &l.root)
}

// PushBack inserts a new element e with value v at the back of list l and returns e.
func (l *List) PushBack(v any) *Element {
	l.lazyInit()
	return l.insertValue(v, l.root.prev)
}

// InsertBefore inserts a new element e with value v immediately before mark and returns e.
// If mark is not an element of l, the list is not modified.
// The mark must not be nil.
func (l *List) InsertBefore(v any, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	// see comment in List.Remove about initialization of l
	return l.insertValue(v, mark.prev)
}

// InsertAfter inserts a new element e with value v immediately after mark and returns e.
// If mark is not an element of l, the list is not modified.
// The mark must not be nil.
func (l *List) InsertAfter(v any, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	// see comment in List.Remove about initialization of l
	return l.insertValue(v, mark)
}

// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *List) MoveToFront(e *Element) {
	if e.list != l || l.root.next == e {
		return
	}
	// see comment in List.Remove about initialization of l
	l.move(e, &l.root)
}

// MoveToBack moves element e to the back of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *List) MoveToBack(e *Element) {
	if e.list != l || l.root.prev == e {
		return
	}
	// see comment in List.Remove about initialization of l
	l.move(e, l.root.prev)
}

// MoveBefore moves element e to its new position before mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List) MoveBefore(e, mark *Element) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark.prev)
}

// MoveAfter moves element e to its new position after mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List) MoveAfter(e, mark *Element) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark)
}

// PushBackList inserts a copy of another list at the back of list l.
// The lists l and other may be the same. They must not be nil.
func (l *List) PushBackList(other *List) {
	l.lazyInit()
	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
		l.insertValue(e.Value, l.root.prev)
	}
}

// PushFrontList inserts a copy of another list at the front of list l.
// The lists l and other may be the same. They must not be nil.
func (l *List) PushFrontList(other *List) {
	l.lazyInit()
	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
		l.insertValue(e.Value, &l.root)
	}
}
相关推荐
std787929 分钟前
Rust 与 Go – 比较以及每个如何满足您的需求
开发语言·golang·rust
sulikey1 小时前
C++的STL：深入理解 C++ 的 std::initializer_list
开发语言·c++·stl·list·initializerlist·c++标准库
埃泽漫笔1 小时前
Redis的List数据结构底层实现
redis·list
小白.cpp1 小时前
list链表容器
数据结构·链表·list
不良人天码星1 小时前
redis的事务，以及watch的原理
数据库·redis·缓存
doris82042 小时前
使用Yum安装Redis
数据库·redis·缓存
Boilermaker19922 小时前
【Redis】哨兵与对脑裂的情况分析
数据库·redis·缓存
007php0072 小时前
猿辅导Java面试真实经历与深度总结(二)
java·开发语言·python·计算机网络·面试·职场和发展·golang
摇滚侠2 小时前
Spring Boot 3零基础教程，WEB 开发 内容协商机制 笔记34
java·spring boot·笔记·缓存
保持低旋律节奏13 小时前
C++——list链表
c++·链表·list
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南072025软件测试面试八股文（含答案+文档）08两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10KGG转MP3工具|非KGM文件|解密音频