Go基础：list的介绍与使用

程序员嘉夫
717 阅读5分钟

Go基础：list的介绍与使用

介绍

Go语言内置容器list是一个双向链表(实际是一个环)。位于包list当中。

结构体定义

list的核心结构体一共包含两个List和Element。

List

List的结构体如下：

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
}

List的结构体包含两个部分：

  • root：类型为Element的结构体。
  • len：用于记录List的长度(除去哨兵节点)。

List的第一个节点为哨兵节点，不存储任何信息。List的头从哨兵节点的下一个节点开始。

Element

List中Element的结构体如下：

type Element struct {
	list *List
	Value interface{}
   	   next, prev *Element
}

从节点的结构体可以看出，list中的一个节点包含四个元素：

  • list：指向List的指针，用于标识当前节点属于哪一个LIST
  • Value：用于存储元素的值。
  • next, prev： 指向Element的指针，用于定位后一个节点与前一个节点。

为了简化实现，List的内部实现为一个环，这样l.root既是最后一个list元素(l.Back())的下一个元素，也是第一个list元素(l.Front())的上一个元素。

方法一览

下面将方法分为六个大类分别讲解：

  • 初始化方法
  • 基本方法
  • 插入元素
  • 删除元素
  • 移动元素
  • 合并链表

初始化

初始化的方法有两个：Init()和lazyInit()。

Init()方法可以用来初始化一个链表，或者是清空链表。

lazyInit()方法懒初始化一个零值的链表，从实现上可以看出，只有当哨兵节点的next节点为空时，才会初始化链表。

func (l *List) Init() *List {
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0
	return l
}

func (l *List) lazyInit() {
	if l.root.next == nil {
		l.Init()
	}
}

基础方法

  • Next()：返回当前节点的下一个节点或者nil。从实现可以看出，当list为空或者下一个节点为哨兵节点时，返回nil。
  • Prev()：返回当前节点的上一个节点或者nil，跟上面类似。
  • New()：返回一个初始化完成的链表。
  • Len()：回链表中的元素个数，时间复杂度为O(1)。
  • Front()：返回链表的第一个元素。当链表为空时，返回nil。
  • Back()：返回链表的最后一个元素。当链表为空时，返回nil。
func (e *Element) Next() *Element {
	if p := e.next; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

func (e *Element) Prev() *Element {
	if p := e.prev; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

func New() *List { return new(List).Init() }

func (l *List) Len() int { return l.len }

func (l *List) Front() *Element {
	if l.len == 0 {
		return nil
	}
	return l.root.next
}

func (l *List) Back() *Element {
	if l.len == 0 {
		return nil
	}
	return l.root.prev
}

插入元素

  • insert()：未导出函数。在元素at的位置后面插入一个元素，链表长度加一，返回插入的元素。
  • insertValue()：未导出函数。将Value包装成Element然后进行insert()。
  • InsertBefore()：调用insertValue()在元素mark前插入。要求元素mark属于调用的链表对象且不为nil。
  • InsertAfter()：与InsertBefore()类似，在元素mark后插入。
  • PushFront()：调用insertValue()方法在表头插入。返回插入的元素。
  • PushBack()：调用insertValue()方法在表尾插入。返回插入的元素。
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
}

func (l *List) insertValue(v interface{}, at *Element) *Element {
	return l.insert(&Element{Value: v}, at)
}

func (l *List) InsertBefore(v interface{}, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	return l.insertValue(v, mark.prev)
}

func (l *List) InsertAfter(v interface{}, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	return l.insertValue(v, mark)
}

func (l *List) PushFront(v interface{}) *Element {
	l.lazyInit()
	return l.insertValue(v, &l.root)
}

func (l *List) PushBack(v interface{}) *Element {
	l.lazyInit()
	return l.insertValue(v, l.root.prev)
}

删除元素

  • remove()：未导出函数。从链表中删除元素e，链表长度减一，返回被删除的元素。
  • Remove()：当元素e属于被调用链表的元素时，调用remove()函数，返回e.Value。
func (l *List) remove(e *Element) *Element {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next = nil	 // 避免内存泄漏
	e.prev = nil	 // 避免内存泄漏
	e.list = nil
	l.len--
	return e
}

func (l *List) Remove(e *Element) interface{} {
	if e.list == l {
		l.remove(e)
	}
	return e.Value
}

移动元素

  • move()：未导出函数。将元素e移至元素at的后面，返回元素e。
  • MoveToFront()：将元素e移至表头。要求元素e属于被调用链表的元素。
  • MoveToBack()：将元素e移至表尾。要求元素e属于被调用链表的元素。
  • MoveBefore()：将元素e移至元素mark的前面。要求元素e属于被调用链表的元素且不为元素mark。
  • MoveAfter()：与MoveBefore()类似，移至其后面。
func (l *List) move(e, at *Element) *Element {
	if e == at {
		return e
	}
	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

	return e
}

func (l *List) MoveToFront(e *Element) {
	if e.list != l || l.root.next == e {
		return
	}
	l.move(e, &l.root)
}

func (l *List) MoveToBack(e *Element) {
	if e.list != l || l.root.prev == e {
		return
	}
	l.move(e, l.root.prev)
}

func (l *List) MoveBefore(e, mark *Element) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark.prev)
}

func (l *List) MoveAfter(e, mark *Element) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark)
}

合并链表

  • PushBackList()：将另一个链表浅拷贝到当前链表的末尾。要求两个链表均不为nil。
  • PushFronList()：将另一个链表浅拷贝到当前链表的开头。要求两个链表均不为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)
	}
}

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)
	}
}

使用

下面从三个方面来讲解list的使用：

  • 基本操作
  • 模拟栈
  • 模拟队列

基本操作

下面演示一下链表的基本使用：

l := list.New()
e4 := l.PushBack(4)
e1 := l.PushFront(1)
l.InsertBefore(3, e4)
l.InsertAfter(2, e1)

// 遍历输出链表内容
for e := l.Front(); e != nil; e = e.Next() {
    fmt.Println(e.Value)
}

输出结果如下：

1
2
3
4

栈

我们知道栈有三个基本操作：Push()、Pop()和Top()，分别是向栈顶压入，弹出，和查看栈顶操作。我们可以用list的方法来模拟这三个基本操作：s.PushBack()、s.Back().Value和s.Remove(s.Back())。

stack := list.New()
stack.PushBack(1)
stack.PushBack(2)
stack.PushBack(3)
stack.PushBack(4)
for stack.Len() > 0 {
    fmt.Println(stack.Remove(stack.Back()))
}

输出如下：

4
3
2
1

队列

同样，我们还可以用q.PushBack()与q.Remove(q.Front())来模拟队列的进度与出队操作。

queue := list.New()
queue.PushBack(1)
queue.PushBack(2)
queue.PushBack(3)
queue.PushBack(4)
for l.Len() > 0 {
    fmt.Println(l.Remove(l.Front()))
}

输出如下：

4
3
2
1
avatar
文章
阅读
粉丝