go 實現並操作單鏈表

實現部分在linkedList包裏面，具體實現的功能有:
1.判斷是否爲空的單鏈表
2.單鏈表的長度
3.獲取頭節點
4.從頭部添加元素
5.從尾部添加元素
6.在指定位置添加元素
7.刪除指定元素
8.刪除指定位置的元素
9.判斷是否包含某個元素

linkedList包代碼如下：

package linkedList

type Object interface{}

type Node struct {
    Data Object
    Next *Node
}

type List struct {
    headNode *Node //頭節點
}

//判斷是否爲空的單鏈表
func (this *List) IsEmpty() bool {
    if this.headNode == nil {
        return true
    } else {
        return false
    }
}

//單鏈表的長度
func (this *List) Length() int {
    cur := this.headNode
    count := 0
    for cur != nil {
        count++
        cur = cur.Next
    }
    return count
}

//獲取頭部節點
func (this *List) GetHeadNode() *Node {
    return this.headNode
}

//從頭部添加元素
func (this *List) Add(data Object) {
    node := &Node{Data: data}
    node.Next = this.headNode
    this.headNode = node
}

//從尾部添加元素
func (this *List) Append(data Object) {
    node := &Node{Data: data}
    if this.IsEmpty() {
        this.headNode = node
    } else {
        cur := this.headNode
        for cur.Next != nil {
            cur = cur.Next
        }
        cur.Next = node
    }
}

//在指定位置添加元素
func (this *List) Insert(index int, data Object) {
    if index < 0 {
        this.Add(data)
    } else if index > this.Length() {
        this.Append(data)
    } else {
        pre := this.headNode
        count := 0
        for count < (index - 1) {
            pre = pre.Next
            count++
        }
        //當循環退出後，pre指向index -1的位置
        node := &Node{Data: data}
        node.Next = pre.Next
        pre.Next = node
    }
}

//刪除指定元素
func (this *List) Remove(data Object) {
    pre := this.headNode

    if pre.Data == data {
        this.headNode = pre.Next
    } else {
        for pre.Next != nil {
            if pre.Next.Data == data {
                pre.Next = pre.Next.Next
            } else {
                pre = pre.Next
            }
        }
    }
}

//刪除指定位置的元素
func (this *List) RemoveAtIndex(index int) {
    pre := this.headNode
    if index <= 0 {
        this.headNode = pre.Next
    } else if index >= this.Length() {
        //報錯 err
    } else {
        count := 0 //index = 3
        for count != (index-1) && pre.Next != nil {
            count++        //2
            pre = pre.Next //2
        }
        pre.Next = pre.Next.Next
    }
}

//是否包含某個元素
func (this *List) Contain(data Object) bool {
    cur := this.headNode
    for cur != nil {
        if cur.Data == data {
            return true
        }
        cur = cur.Next
    }
    return false
}

// 反轉鏈表
func (this *List) Revrese() {
	head := this.headNode
	if head ==nil || head.Next == nil {
		return
	}
	pre := List{}
	for head != nil {
		pre.Add(head.Data)
		head = head.Next
	}
	this.headNode = pre.headNode
}

測試代碼在main.go中，相關測試如下

package main

import (
    "algorithm/linkedList"
    "fmt"
)

func main() {
    list := linkedList.List{}

    //1.往單鏈表末尾追加元素2, 3, 4, 5
    list.Append(1)
    list.Append(2)
    list.Append(3)
    list.Append(4)

    //2.從頭部添加元素head_node
    list.Add("head_node")

    fmt.Println("長度======", list.Length())

    //3.判斷是否爲空鏈表
    bool := list.IsEmpty()
    fmt.Println(bool)

    //4.在指定位置2插入元素 2indexValue
    list.Insert(2, "2_index_value")
    travselLinkList(&list)

    //5.是否包含元素2_index_value
    isContain := list.Contain("2_index_value")
    fmt.Println("isContain[2_index_value]:", isContain)

    //6.刪除元素2_index_value
    list.Remove("2_index_value")
    travselLinkList(&list)

    //7.從位置2刪除元素
    list.RemoveAtIndex(2)
    travselLinkList(&list)

}

func travselLinkList(list *linkedList.List) {
    //遍歷
    head := list.GetHeadNode()
    for head != nil {
        fmt.Println(head.Data)
        head = head.Next
    }
    fmt.Println("--------------------")
}