重溫一遍資料結構之單連結串列（golang版）

說明

上一篇說的是線性表中的順序儲存結構，他的讀取複雜度雖然是o(1)，但是它的缺點也很明顯，插入和刪除需要移動很多元素，而且需要分配一塊連續的記憶體區域

線性表之單連結串列

單連結串列在一定程度上解決了一部分上面的問題，而且也不要一大塊連續的記憶體區域，程式碼如下

package main

//線性表中的鏈式儲存結構
//第一個節點為頭節點，並不真實儲存資料，頭節點基本代表了整個連結串列

import (
    "fmt"
)

type Elem int

type LinkNode struct {
    Data Elem
    Next *LinkNode
}

//生成頭節點
func New() *LinkNode {
    //下面的data可以用來表示連結串列的長度
    return &LinkNode{0, nil}
}

//在連結串列的第i個位置前插入一個元素e，複雜度為o(n)
func (head *LinkNode) Insert(i int, e Elem) bool {
    p := head
    j := 1
    for nil != p && j < i {
        p = p.Next
        j++
    }
    if nil == p || j > i {
        fmt.Println("pls check i:", i)
        return false
    }
    s := &LinkNode{Data: e}
    s.Next = p.Next
    p.Next = s
    return true
}

//遍歷連結串列
func (head *LinkNode) Traverse() {
    point := head.Next
    for nil != point {
        fmt.Println(point.Data)
        point = point.Next
    }
    fmt.Println("--------done----------")
}

//刪除連結串列中第i個節點，複雜度為o(n)
func (head *LinkNode) Delete(i int) bool  {
    p := head
    j := 1
    for (nil != p && j < i) {
        p = p.Next
        j++
    }
    if nil == p || j > i {
        fmt.Println("pls check i:", i)
        return false
    }

    p.Next = p.Next.Next
    return true
}

// 獲取連結串列中的第i個元素，複雜度為o(n)
func (head *LinkNode) Get(i int) Elem  {
    p := head.Next
    for j:= 1; j< i ;j++  {
        if nil == p {
            //表示返回錯誤
            return -100001
        }
        p=p.Next
    }

    return p.Data
}

func main() {
    linkedList := New()
    linkedList.Insert(1, 9)
    linkedList.Insert(1, 99)
    linkedList.Insert(1, 999)
    linkedList.Insert(1, 9999)
    linkedList.Insert(1, 99999)
    linkedList.Insert(1, 999999)
    linkedList.Traverse()

    linkedList.Delete(4)
    linkedList.Traverse()


    e := linkedList.Get(4)
    fmt.Println(e)
}