golang 单链表实现

//单链表实现

/************************

1.判断是否为空的单链表

2.单链表的长度

3.从头部添加元素

4.送尾部添加元素

5.在指定位置添加元素

6.删除指定元素

7.删除指定位置元素

8.查看是否包含某个元素

9.遍历所有元素

*************************/

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++

		count++

		//对地址进行逐个位移

		cur = cur.Next

	}

	return count

}

//从链表头部添加元素

func (this *List) Add(data Object) *Node {

	node := &Node{Data: data}

	node.Next = this.headNode

	this.headNode = node

	return node

}

//从尾部添加元素

func (this *List) Append(data Object) {

	//创建一个新元素通过data 参数进行数据域的赋值

	node := &Node{Data: data}

	if this.IsEmpty() { //如果该链表为空，那么直接将元素作为头节点

		this.headNode = node

	} else {

		//如果链表不为空

		cur := this.headNode  //定义变量用于存储头节点

		for cur.Next != nil { //判断是否为尾结点，如果nil则该节点是尾结点

			cur = cur.Next //链表进行位移，知道cur获取到尾结点

		}

		cur.Next = node

	}

}

//在指定位置添加元素，此处index只下标，this.headNode的index

func (this *List) Insert(index int, data Object) {

	if index < 0 { //如果index<0,则进行头部插入

		this.Add(data)

	} else if index > this.Length() {

		//如果index > 链表长度，则进行尾部插入

		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  //定义变量pre,存储头节点

	if pre.Data == data { //如果该节点的数据域的值为data

		this.headNode = pre.Next

	} else {

		//如果删除的不是头节点

		for pre.Next != nil { //循环判断是否遍历到最后一个节点，如果不是，则进行如下判断

			if pre.Next.Data == data { //如果pre.next的节点的数据等于data,那么删除该节点，pre.Next指向该节点之后的节点地址

				pre.Next = pre.Next.Next

			} else { //如果pre.Next的节点的数据等于data,那么进行节点位移，循环判断

				pre = pre.Next

			}

		}

	}

}

//删除指定位置元素

func (this *List) ReMoveAtIndex(index int) {

	pre := this.headNode

	if index <= 0 { //如果index为0或者小于0，那么删除节点

		this.headNode = pre.Next //第二个节点作为头节点

	} else if index > this.Length() { //如果传入的参数大于链表长度，则报错，退出程序

		fmt.Println("超出链表的长度")

		return

	} else {

		count := 0 //定义计数器

		for count != (index-1) && pre.Next != nil {

			//开始遍历，如果index=1,则跳出循环，直接删除，如果index>1,则进行表位移，然后删除

			count++

			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) ShowList() {

	if !this.IsEmpty() {

		cur := this.headNode

		for {

			fmt.Println("====", cur.Data)

			if cur.Next != nil {

				cur = cur.Next

			} else {

				break

			}

		}

	}

}

//测试代码

func main() {

	//初始化链表list

	list := List{}

	list.Append(1)

	list.Append(2)

	list.Append(3)

	list.Append(4)

	list.Append("a")

	list.Append("b")

	list.Append("c")

	list.Append("d")

	fmt.Println("链表的长度为", list.Length())

	fmt.Println("链表List当前的数值：")

	list.ShowList()

	fmt.Println()

	//判断链表是是否为空

	list2 := List{}

	fmt.Println("list 是否为空链表", list.IsEmpty())

	fmt.Println("List 是否为空链表：", list2.IsEmpty())

	//在指定位置index =5,value b处插入five_insert_value

	list.Insert(5, "five_insert_value")

	fmt.Println("链表List 当前的数值为：")

	list.ShowList()

	//测试是否包含five_insert_value

	isContain := list.Contain("five_insert_value")

	fmt.Println("isContain [five_insert_value]：", isContain)

	//删除元素five_insert_value

	list.Remove("five_insert_value")

	fmt.Println("链表List 当前的值为：")

	list.ShowList()

	fmt.Println()

	//删除元素位置index =3 ,value=3

	list.ReMoveAtIndex(3)

	fmt.Println("链表Lsit 当前的数值为：")

	list.ShowList()

	fmt.Println()

	list.ShowList()

	fmt.Println()

}