//单链表实现
/************************
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()
}