（4-4）容器（Container）：List列表

4.4  List列表

列表是一种非连续的存储容器，由多个节点组成，节点通过一些变量记录彼此之间的关系，列表有多种实现方法，如单链表、双链表等。

4.4.1  列表的原理

在 Go 语言中，列表通常是使用双向链表实现的。双向链表是一种数据结构，每个节点除了包含一个元素之外，还包含了指向前一个节点和后一个节点的指针，因此可以双向遍历链表。双向链表通常使用结构体来表示节点，结构体中包含一个元素值，以及指向前一个节点和后一个节点的指针。比如：

type node struct {
    value interface{}
    prev  *node
    next  *node
}

列表的头部和尾部通常也是节点。对于双向链表的操作，通常包括添加、删除、遍历等。在添加节点时，可以将新节点插入到链表的头部或尾部，具体取决于实现方式。在删除节点时，需要断开该节点与前一个节点和后一个节点的连接，并重新连接前一个节点和后一个节点。在遍历节点时，可以从头部开始或尾部开始遍历，然后依次访问每个节点的值。

列表的原理可以这样理解：假设 A、B、C 三个人都有电话号码，如果 A 把号码告诉给 B，B 把号码告诉给 C，这个过程就建立了一个单链表结构，如下图4-1所示。

图4-1  三人单向通知电话号码形成单链表结构

如果在这个基础上，再从 C 开始将自己的号码告诉给自己所知道号码的主人，这样就形成了双链表结构，如下图4-2所示。

图4-2  三人相互通知电话号码形成双链表结构

那么如果需要获得所有人的号码，只需要从 A 或者 C 开始，要求他们将自己的号码发出来，然后再通知下一个人如此循环，这样就构成了一个列表遍历的过程。

假设后来B 换号码了，他需要通知 A 和 C，将自己的号码移除，这个过程就是列表元素的删除操作，如下图4-3所示。

图4-3  从双链表中删除一人的电话号码

在实现列表时，需要考虑并发安全性。如果列表可能会被多个 Goroutine 并发访问，则需要采用适当的同步措施，比如使用互斥锁来保证只有一个 Goroutine 可以修改列表。

4.4.2  Go语言的列表实现

在 Go 语言中，list 是标准库 container/list 包提供的双向链表（doubly linked list）实现。list 的特点是支持高效的插入和删除操作，可以在常数时间内完成这些操作。在 Go 语言list中包含了如下常用的内置方法：

1. New()：创建一个新的链表并返回其指针。
2. Len() int：返回链表中元素的数量。
3. Front() *Element：返回链表的第一个元素，如果链表为空，则返回 nil。
4. Back() *Element：返回链表的最后一个元素，如果链表为空，则返回 nil。
5. PushFront(v interface{}) *Element：在链表的前面插入一个值为 v 的新元素，并返回新元素的指针。
6. PushBack(v interface{}) *Element：在链表的后面插入一个值为 v 的新元素，并返回新元素的指针。
7. InsertBefore(v interface{}, mark *Element) *Element：在链表中 mark 元素的前面插入一个值为 v 的新元素，并返回新元素的指针。
8. InsertAfter(v interface{}, mark *Element) *Element：在链表中 mark 元素的后面插入一个值为 v 的新元素，并返回新元素的指针。
9. MoveToFront(e *Element)：将元素 e 移动到链表的前面。
10. MoveToBack(e *Element)：将元素 e 移动到链表的后面。
11. MoveBefore(e, mark *Element)：将元素 e 移动到 mark 元素的前面。
12. MoveAfter(e, mark *Element)：将元素 e 移动到 mark 元素的后面。
13. Remove(e *Element) interface{}：从链表中删除元素 e，并返回其值。

在 Go 语言中，list 中的元素是 Element 类型的，包含了一个值和指向前后两个元素的指针。因此，在使用 list 时，需要通过操作元素的指针来进行插入、删除、移动等操作。另外，由于 list 中的元素是双向链表实现的，因此可以高效地在链表的两端进行插入和删除操作。

实例4-7：列表元素的添加、修改、删除和遍历（源码路径：Go-codes\4\lie.go）

实例文件lie.go的具体实现代码如下所示。

package main
import (
	"container/list"
	"fmt"
)
type Person struct {
	Name string
	Age  int
}

func main() {
	// 创建一个新的链表
	personList := list.New()
	// 向链表中添加元素
	person1 := Person{Name: "Alice", Age: 20}
	element1 := personList.PushBack(person1)

	person2 := Person{Name: "Bob", Age: 25}
	element2 := personList.PushBack(person2)

	// 修改链表中的元素
	newPerson := Person{Name: "David", Age: 35}
	element2.Value = newPerson
	// 遍历链表并输出每个元素
	for element := personList.Front(); element != nil; element = element.Next() {
		person := element.Value.(Person)
		fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
	}
	// 从链表中删除元素
	personList.Remove(element1)
	// 再次遍历链表并输出每个元素
	for element := personList.Front(); element != nil; element = element.Next() {
		person := element.Value.(Person)
		fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
	}
}

在上述代码中创建了一个链表 personList，并向其中添加了三个元素。每个元素都是一个 Person 类型的结构体。我们可以使用 PushBack() 方法将一个元素添加到链表的末尾。在修改元素时，我们可以通过元素的指针来访问和修改其值。在遍历链表时，我们可以使用 Front() 方法获取链表的第一个元素，然后通过 Next() 方法获取下一个元素。最后，我们使用 Remove() 方法从链表中删除一个元素。执行后会输出：

Name: Alice, Age: 20
Name: David, Age: 35
Name: David, Age: 35

注意：在 list 中存储的元素是 interface{} 类型的，因此在使用时需要进行类型转换。在上面的例子中，我们使用了类型断言来将 element.Value 转换为 Person 类型。