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("--------------------")
}