重溫一遍數據結構之單鏈表（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)
}