Go标准库的container/list实现的是双向链表，结构上每个节点包含前驱和后继指针，因此头部插入、尾部插入、以及按位置插入的时间复杂度都是O(1)。这个包位于标准库，不需要第三方依赖，适合维护有序序列、构建队列或实现LRU淘汰策略。要正确使用它，需要理解Element的指针语义、Value的interface{}类型以及遍历过程中的删除策略。
认识container/list的双向链表结构
container/list中的List结构实际上维护了一个哨兵节点root，这个root本身不保存业务数据，只是用来连接头部和尾部。初始化时root.next和root.prev都指向root自身，形成一个空的双向循环链表。对外暴露的Front()方法返回root.next，Back()方法返回root.prev。当链表为空时，这两个方法都会返回nil。每个业务节点用Element表示，它保存了Value、next、prev以及指向所属链表的指针list。理解这种哨兵节点设计，再看链表长度和空表状态就非常直观。
创建一个链表通常使用list.New()，但也可以直接声明var l list.List，两种方式最终都能得到可用的链表。区别在于list.New()会显式初始化内部的root指针，而零值List在第一次访问Front或Back前也会被惰性初始化。向链表插入元素时，PushBack会在root.prev后面插入新节点，PushFront会在root.next前面插入。由于root是循环哨兵，头部和尾部操作本质上都是常数时间的指针调整，不会因为链表长度增加而变慢。
下面是一个最小化的创建和遍历示例：
package main
import (
"container/list"
"fmt"
)
func main() {
l := list.New()
l.PushBack("Go")
l.PushBack("容器")
l.PushFront("你好")
for e := l.Front(); e != nil; e = e.Next() {
fmt.Println(e.Value)
}
}
上面的代码先创建链表，然后在尾部插入两个元素，再在头部插入一个元素。最终遍历顺序是：你好、Go、容器，这符合双向链表头部插入在最前、尾部插入在最后的特点。注意e.Value的类型是interface{}，打印时fmt会自动处理，但业务中通常需要类型断言才能得到具体值。
插入、删除与移动操作实践
list提供了非常完整的方法集。InsertBefore(v, mark)和InsertAfter(v, mark)接收一个mark *Element作为参考节点，将新值插入到它的前面或后面。如果mark不属于当前链表，InsertBefore会返回nil并且不会修改链表。Remove(e)返回e.Value，删除后该Element的next和prev会被置为nil，但Value仍然保留在返回的接口中，方便调用方继续处理。PushFront和PushBack可以理解为InsertBefore和InsertAfter的便捷封装，分别参考root.next和root.prev。MoveToFront和MoveToBack则用于把已有节点移动到链表两端。
这些方法在实际开发中非常实用。比如维护一个最近使用列表时，可以用MoveToFront把访问到的元素提到前面，这是实现LRU的基础。由于方法都接收*Element，使用时需要保存节点引用。常见的做法是在map中维护key到*Element的映射，这样就能通过key快速拿到链表中的节点并移动，不需要线性查找。删除元素时同样依赖这个映射，否则只能从Front或Back开始逐个比对Value。
下面演示插入、删除和移动的组合操作：
package main
import (
"container/list"
"fmt"
)
func main() {
l := list.New()
first := l.PushBack("first")
second := l.PushBack("second")
l.InsertBefore("middle", second)
fmt.Println(l.Remove(first))
l.MoveToFront(second)
for e := l.Front(); e != nil; e = e.Next() {
fmt.Println(e.Value)
}
}
运行后首先输出被删除的first，然后MoveToFront把second移动到链表头部。最后遍历时，second排在middle之前，因此输出顺序是second、middle。这个例子展示了链表如何在O(1)时间内完成基于节点引用的插入、删除和移动，不需要像切片那样搬移后续元素。
遍历和删除容易踩的坑
在遍历container/list时，最容易出错的地方是边遍历边删除节点。常见错误写法是在调用Remove(e)之后继续执行e = e.Next()。Remove会把e.next和e.prev置为nil，这时再访问e.Next()会拿到nil，循环直接退出，导致漏掉后面的节点。如果后续还使用e.prev甚至可能引发panic。更隐蔽的问题是，即使不立即出错，由于链表结构被修改，旧游标指向的节点可能已经脱离链表，继续遍历会跳过某些节点或进入错误状态。
正确做法是在删除当前节点之前先保存next := e.Next()，然后执行删除逻辑，最后把e赋值为next。这个next在删除前取得，不受Remove影响。如果只想删除满足条件的节点，且删除后不需要立即使用被删节点，也可以使用临时变量保存下一个节点。另外如果目标只是清空链表，可以调用l.Init()，它会重置链表，比遍历一个个删除更直接。不过Init并不会主动释放旧节点内存，但原来的Element失去引用后由GC回收。
下面是一个安全删除节点的示例：
package main
import (
"container/list"
"fmt"
)
func main() {
l := list.New()
l.PushBack("a")
l.PushBack("b")
l.PushBack("c")
for e := l.Front(); e != nil; {
next := e.Next()
if e.Value == "b" {
l.Remove(e)
}
e = next
}
for e := l.Front(); e != nil; e = e.Next() {
fmt.Println(e.Value)
}
}
这段代码先保存next，再删除满足条件的节点，最后将游标移动到next。运行结果是a和c，中间的b被成功删除。这个模式在处理过滤操作时非常稳定，可以避免因为删除当前节点导致遍历中断。如果遇到需要在遍历中插入节点的场景，也要注意插入后是否会影响后续遍历顺序，必要时使用专门的收集列表，遍历完成后再统一插入。
基于container/list实现LRU缓存
LRU缓存淘汰的核心是：访问一个key时把它标记为最近使用；写入新key时如果超过容量，则移除最久未使用的key。双向链表非常适合维护这个使用顺序，链表头部表示最近使用，尾部表示最久未使用。map提供O(1)的key查找能力，将key映射到*list.Element，这样访问时无需遍历链表。两者结合可以构造一个时间复杂度接近O(1)的LRU缓存。
定义entry结构保存key和value，因为链表元素只保存一个Value接口，如果仅仅存value，从链表尾部淘汰时无法知道对应的map key。把key一并存进去，淘汰时从entry中取回key，再从map中删除。value使用interface{}保持通用性，也可以根据业务改成具体类型。
下面是一个完整的LRU缓存实现：
package main
import (
"container/list"
"fmt"
)
type LRUCache struct {
capacity int
list *list.List
items map[string]*list.Element
}
type entry struct {
key string
value interface{}
}
func NewLRUCache(capacity int) *LRUCache {
return &LRUCache{
capacity: capacity,
list: list.New(),
items: make(map[string]*list.Element),
}
}
func (c *LRUCache) Get(key string) (interface{}, bool) {
if e, ok := c.items[key]; ok {
c.list.MoveToFront(e)
return e.Value.(entry).value, true
}
return nil, false
}
func (c *LRUCache) Put(key string, value interface{}) {
if e, ok := c.items[key]; ok {
e.Value = entry{key: key, value: value}
c.list.MoveToFront(e)
return
}
if c.list.Len() >= c.capacity {
oldest := c.list.Back()
if oldest != nil {
c.list.Remove(oldest)
delete(c.items, oldest.Value.(entry).key)
}
}
e := c.list.PushFront(entry{key: key, value: value})
c.items[key] = e
}
func main() {
cache := NewLRUCache(2)
cache.Put("a", 1)
cache.Put("b", 2)
fmt.Println(cache.Get("a"))
cache.Put("c", 3)
if _, ok := cache.Get("b"); !ok {
fmt.Println("b was evicted")
}
fmt.Println(cache.Get("a"))
fmt.Println(cache.Get("c"))
}
在Get中如果key存在，就调用MoveToFront把对应节点移到链表头部，表示最近访问过。Put时先判断key是否已存在，存在则更新值并移动节点。如果不存在且链表长度已经达到容量，就从Back()取出最久未使用的节点，删除它并从map中移除对应key。这个实现中链表头部是最近使用，尾部是最久未使用，因此淘汰时直接操作Back()即可。
什么时候选择list而不是slice
slice的优势是连续内存，按索引访问O(1)，尾部追加均摊O(1)，并且CPU缓存命中率高。list的优势是中间插入删除O(1)，不需要搬移其他元素。但list的每个节点都单独分配在堆上，导致内存碎片和额外指针开销，遍历时指针跳转缺少空间局部性。在Go中，很多业务集合规模不大，slice即使中间插入也可能因为复制少量元素而很快；list真正占优的场景是元素非常大，或者插入删除非常频繁且位置不固定。
另一个考量是类型安全。list的元素是interface{}，每次取值都需要类型断言，断言失败会panic。如果无法接受运行时错误，可以封装一层泛型方法，或者使用[]T。Go 1.18之后可以自己写一个简单的泛型链表，但标准库container/list至今未泛型化，这可能也是很多团队在业务代码中回避它的原因之一。可以根据维护成本决定：如果只是需要一个队列或栈，用slice配合append和reslice也能满足大部分需求。
总结来看，container/list适合LRU缓存、最近使用列表、需要O(1)删除的调度队列等场景。普通顺序存储和大量读多写少场景，优先选择slice。把两者结合起来使用，例如切片负责索引和连续读，链表负责维护顺序，可以在保证功能的同时获得不错的性能表现。
container/listGolang链表list链表操作修改时间：2026-09-30 15:22:36