GO語言list剖析

GO語言list剖析

本節內容

1. 使用方法
2. list提供的方法
3. 源碼剖析

1. 使用方法

在GO語言的標準庫中，提供了一個container包，這個包中提供了三種數據類型，就是heap,list和ring，本節要講的是list的使用以及源碼剖析。
要使用GO提供的list鏈表，則首先須要導入list包，以下所示：

package main
import(
    "container/list"
)

導入包以後，須要瞭解list中定義了兩種數據類型，Element和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{}
}

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裏面定義了兩個Element類型的指針next, prev以及List類型的指針list, Value用來存儲值，List裏面定義了一個Element做爲鏈表的Root，len做爲鏈表的長度。

import以後，就能夠使用鏈表了：

func main()  {
    list_test:=list.New()  // 建立list對象
    list_test.PushBack("123")  // 往List隊列尾部插入數據
    list_test.PushBack("456")
    list_test.PushBack("789")
    fmt.Println(list_test.Len())  // 輸出list長度
    fmt.Println(list_test.Front())  // 輸出list第一個元素
    fmt.Println(list_test.Front().Next())  // 輸出list第一個元素的下一個元素
    fmt.Println(list_test.Front().Next().Next())  // 輸出list第三個元素
}

2. list提供的方法

list提供的方法以下：

type Element
    func (e *Element) Next() *Element
    func (e *Element) Prev() *Element
type List
    func New() *List
    func (l *List) Back() *Element   // 返回最後一個元素
    func (l *List) Front() *Element  // 返回第一個元素
    func (l *List) Init() *List  // 鏈表初始化
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element // 在某個元素前插入
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element  // 在某個元素後插入
    func (l *List) Len() int // 返回鏈表長度
    func (l *List) MoveAfter(e, mark *Element)  // 把e元素移動到mark以後
    func (l *List) MoveBefore(e, mark *Element)  // 把e元素移動到mark以前
    func (l *List) MoveToBack(e *Element) // 把e元素移動到隊列最後
    func (l *List) MoveToFront(e *Element) // 把e元素移動到隊列最頭部
    func (l *List) PushBack(v interface{}) *Element  // 在隊列最後插入元素
    func (l *List) PushBackList(other *List)  // 在隊列最後插入接上新隊列
    func (l *List) PushFront(v interface{}) *Element  // 在隊列頭部插入元素
    func (l *List) PushFrontList(other *List) // 在隊列頭部插入接上新隊列
    func (l *List) Remove(e *Element) interface{} // 刪除某個元素

3. 源碼剖析

首先，使用list.New()方法，返回的是一個List對象的指針，源碼func New() *List { return new(List).Init() }並執行了List對象的Init()方法對list進行初始化，初始化root的prev和next指針以及list的長度。
以後調用list_test.PushBack("123")在隊列尾部插入元素123，源碼以下：

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

調用lazyInit(),若是鏈表沒有初始化，則先初始化一遍，以後，調用list的insertValue方法，insertValue方法初始化節點以後，調用insert方法進行插入鏈表。

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

整篇文章最精髓的地方就在insert方法中了，源碼以下：

func (l *List) insert(e, at *Element) *Element {
    n := at.next  // 用中間變量n保存at節點的next指針
    at.next = e  // at節點的next指向要插入的節點
    e.prev = at  // 要插入的節點e的prev指向at節點
    e.next = n  // e的next節點指向中間變量n保存的指針
    n.prev = e  // at節點的下一個節點的prev指向e節點
    e.list = l  // e節點的list指向鏈表的root節點
    l.len++  // 鏈表的長度加一
    return e  // 返回剛插入節點的指針
}

這裏的鏈表結構是雙向鏈表，而且在root節點的prev指針指向了鏈表的結尾，鏈表結尾的next指針也指向了root節點，這樣，其實造成了一個環形結構，若是是向鏈表的尾部插入新數據，則將root.prev傳遞給insert方法的at參數，若是是向頭部插入，則將root傳遞給insert方法的at參數。

這樣作的好處是顯而易見的，那就是從鏈表的尾部插入數據，將不須要遍歷一遍鏈表，而只須要將root節點的prev傳遞給insert方法中就能夠了，大大節省了從尾部插入節點的時間。這段代碼我看了好久，以爲這個包中最精髓的地方也就在這了，這也是這篇文章誕生的緣由。

源碼以下：

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

// 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.
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.
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 {
    n := at.next
    at.next = e
    e.prev = at
    e.next = n
    n.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 interface{}, at *Element) *Element {
    return l.insert(&Element{Value: v}, at)
}

// remove removes e from its list, decrements l.len, and returns e.
func (l *List) remove(e *Element) *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--
    return e
}

// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
func (l *List) Remove(e *Element) interface{} {
    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 interface{}) *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 interface{}) *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.
func (l *List) InsertBefore(v interface{}, 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.
func (l *List) InsertAfter(v interface{}, 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.
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.insert(l.remove(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.
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.insert(l.remove(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.
func (l *List) MoveBefore(e, mark *Element) {
    if e.list != l || e == mark || mark.list != l {
        return
    }
    l.insert(l.remove(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.
func (l *List) MoveAfter(e, mark *Element) {
    if e.list != l || e == mark || mark.list != l {
        return
    }
    l.insert(l.remove(e), mark)
}

// PushBackList inserts a copy of an other list at the back of list l.
// The lists l and other may be the same.
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 an other list at the front of list l.
// The lists l and other may be the same.
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)
    }
}