Golang:List

List的接口

func New() *List                                                    //創建List
func (l *List) Back() *Element                                      //返回List的上一個元素
func (l *List) Front() *Element                                     //返回List下一個元素
func (l *List) Init() *List                                         //初始化List
func (l *List) InsertAfter(v interface{}, mark *Element) *Element   //在指定節點后插入，成功返回插入節點的指針，失敗返回nil, 時間復雜度O(1)
func (l *List) InsertBefore(v interface{}, mark *Element) *Element  //在指定節點之前插入， 成功返回插入節點的指針，失敗返回nil, 時間復雜度O(1)
func (l *List) Len() int                                            //返回鏈表長度，時間復雜度O(1)
func (l *List) MoveAfter(e, mark *Element)                          //移動節點e到mark節點之后，時間復雜度O(1), 處理方式：先刪除然后再插入
func (l *List) MoveBefore(e, mark *Element)                         //移動節點e到mark節點之前，時間復雜度O(1), 處理方式：先刪除然后再插入
func (l *List) MoveToBack(e *Element)                               //移動節點e到鏈表的尾部
func (l *List) MoveToFront(e *Element)                              //移動節點e到鏈表的頭部
func (l *List) PushBack(v interface{}) *Element                     //在鏈表尾部追加值為v的新節點
func (l *List) PushBackList(other *List)                            //把鏈表other所有節點追加到當前鏈表的尾部
func (l *List) PushFront(v interface{}) *Element                    //在鏈表的頭部插入新節點
func (l *List) PushFrontList(other *List)                           //把鏈表other所有節點追加到當前鏈表頭部
func (l *List) Remove(e *Element) interface{}                       //刪除指定節點

從這些接口我們可以看到Go的list應該是一個雙向鏈表，不然InsertBefore這種操作應該不會放出來。

然后我們再從源碼看看List的結構

// Element is an element of a linked list.
type Element struct {
    // Next and previous pointers in the doubly-linked list of elements.
    // To simplify the implementation, internally a list l is implemented
    // as a ring, such that &l.root is both the next element of the last
    // list element (l.Back()) and the previous element of the first list
    // element (l.Front()).
    next, prev *Element

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

    // The value stored with this element.
    Value interface{}
}

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

從這里證實了上面的猜想，這是一個雙向鏈表

List的使用

package main

import (
    "container/list"
    "fmt"
)

func main() {

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

    for e := list0.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }
    fmt.Println("\r")

    front := list0.Front()
    back := list0.Back()

    fmt.Println("front is:", front.Value)
    fmt.Println("back is:", back.Value)
    fmt.Println("length is", list0.Len())

    list0.InsertBefore(0, front)
    list0.InsertAfter(5, back)

    list0.PushFront(-1)
    list0.PushBack(6)
    for e := list0.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }
    fmt.Println("\r")
    list0.Remove(list0.Front())
    for e := list0.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }

    fmt.Println("\r")
    list1 := list.New()
    list1.PushBack(7)
    list1.PushBack(8)
    list0.PushBackList(list1)
    for e := list0.Front(); e != nil; e = e.Next() {
        fmt.Print(e.Value, " ")
    }
    fmt.Println("\r")
}

10-14行往list寫入1，2，3，4

16行遍歷打印list

21-16行打印front 和back節點

42-48行把另一個list追加到list的back

 

運行結果是：

1 2 3 4 
front is: 1
back is: 4
length is 4
-1 0 1 2 3 4 5 6 
0 1 2 3 4 5 6 
0 1 2 3 4 5 6 7 8