go语言 单链表与双链表的基本操作

• 单链表

package main

import "fmt"

//单链表的基本使用

type HeroNode struct {
	No       int
	Name     string
	Nickname string
	NextNode *HeroNode
}

//像链表追加元素
func (this *HeroNode)AppendNode(node *HeroNode)  {
	//定义一个过度变量，用来保存最后一个节点
	tmp := this

	//找到链表的最后一个
	for {
		if tmp.NextNode == nil {
			break
		}else {
			tmp = tmp.NextNode
		}
	}

	//赋值
	tmp.NextNode = node
}


//像链表追加元素
func (this *HeroNode)AppendNode2(node *HeroNode)  {
	//定义一个过度变量，用来保存最后一个节点
	tmp := this

	//找到链表的最后一个
	for {

		if tmp.NextNode == nil {
			tmp.NextNode = node
			break
		}else {

			if node.No < tmp.NextNode.No {

				node.NextNode = tmp.NextNode
				tmp.NextNode = node
				break
			}else {
				tmp = tmp.NextNode
			}
		}
	}

}

//遍历链表
func (this *HeroNode)Each()  {

	//判断链表是否为空
	if this.NextNode == nil {
		fmt.Println("linked is empty")
		return
	}

	//创建一个过度变量，用来保存循环的每一个节点
	tmp := this.NextNode
	for {
		fmt.Printf("[no:%v,name:%v,nickname:%v,add:%p]\n",tmp.No,tmp.Name,tmp.Nickname,tmp)
		if tmp.NextNode == nil {
			break
		}else {
			tmp = tmp.NextNode
		}
	}


}

//列表删除
func (this *HeroNode)Del(no int)  {
	tmp := this

	flag := false
	for {
		if tmp.NextNode == nil {
			break
		}else if tmp.NextNode.No == no {
			flag = true
			break
		}
		tmp = tmp.NextNode
	}

	if flag {
		tmp.NextNode = tmp.NextNode.NextNode
	}else {
		fmt.Println("删除失败")
	}
}

//修改
func (this *HeroNode)Update(no int,node *HeroNode)  {
	tmp := this

	flag := false
	for {
		if tmp.No == no {
			//判断字段是否存在
			if node.Name != "" {
				tmp.Name = node.Name
			}

			if node.Nickname != "" {
				tmp.Nickname = node.Nickname
			}
			flag = true
			break
		}

		if tmp.NextNode == nil {
			break
		}else {
			tmp = tmp.NextNode
		}
	}

	if !flag {
		fmt.Println("数据不存在")
	}
}

//查找
func (this *HeroNode)Get(no int) *HeroNode  {
	tmp := this
	flag := false
	for {
		if tmp.No == no {
			flag = true
			break
		}

		if tmp.NextNode == nil {
			break
		}else {
			tmp = tmp.NextNode
		}
	}

	if !flag {
		fmt.Println("数据不存在")
		return nil
	}else {
		return tmp
	}
}
func main() {
	//实例化表头
	head := &HeroNode{}

	//实例化第一条数据
	gangan := &HeroNode{
		No: 1,
		Name: "gangan",
		Nickname: "gg",
	}

	tt := &HeroNode{
		No: 2,
		Name: "tingting",
		Nickname: "dazhuang",
	}

	head.AppendNode2(tt)
	head.AppendNode2(gangan)
	tt = &HeroNode{
		No: 5,
		Name: "tingting",
		Nickname: "dazhuang",
	}
	head.AppendNode2(tt)
	tt = &HeroNode{
		No: 3,
		Name: "tingting",
		Nickname: "dazhuang",
	}
	head.AppendNode2(tt)
	tt = &HeroNode{
		No: 4,
		Name: "tingting",
		Nickname: "dazhuang",
	}
	head.AppendNode2(tt)
	tt = &HeroNode{
		No: 8,
		Name: "tingting",
		Nickname: "dazhuang",
	}
	head.AppendNode2(tt)
	tt = &HeroNode{
		No: 6,
		Name: "tingting",
		Nickname: "dazhuang",
	}
	head.AppendNode2(tt)

	//删除节点
	//head.Del(1)
	//head.Del(4)
	//head.Del(6)
	head.Update(4,&HeroNode{Nickname: "gangan-xiegai",Name: "干干修改"})

	find := head.Get(4)

	fmt.Println(find)
	//head.Each()
}

• 双链表

package main

import "fmt"

type HeroNode struct {
	No       int
	Name     string
	Nickname string
	Prev     *HeroNode
	Next     *HeroNode
}

//插入
func (this *HeroNode)Insert(node *HeroNode)  {
	tmp := this
	for {
		if tmp.Next == nil {
			break
		}

		tmp = tmp.Next
	}

	tmp.Next = node
	node.Prev = tmp
}

//按照顺序插入
func (this *HeroNode)InsertByAsc(node *HeroNode)  {

	tmp := this
	for {
		if tmp.Next == nil {
			break
		}

		if tmp.Next.No > node.No{
			break
		}else {
			tmp = tmp.Next
		}
	}

	node.Next 	= tmp.Next
	tmp.Next 	= node
	node.Prev 	= tmp
	if node.Next != nil {
		node.Next.Prev = node
	}

}

//删除
func (this *HeroNode)Del(no int)  {
	flag := false
	for {
		if this.No == no {
			this.Prev.Next = this.Next
			if this.Next != nil {
				this.Next.Prev = this.Prev
			}

			flag = true
			break
		}

		if this.Next == nil {
			break
		}else {
			this = this.Next
		}
	}

	if !flag {
		fmt.Println("删除失败")
	}
}

//遍历
func (this *HeroNode)Each()  {

	if this.Next == nil {
		fmt.Println("链表为空")
		return
	}

	tmp := this.Next
	for{

		fmt.Printf("[no:%v,name:%v,nickname:%v,prev:%p,next:%p]\n",tmp.No,tmp.Name,tmp.Nickname,tmp.Prev,tmp.Next)
		if tmp.Next == nil {
			break
		}
		tmp = tmp.Next
	}
}

//倒序遍历
func (this *HeroNode)EachRevers()  {

	if this.Next == nil {
		fmt.Println("链表为空")
		return
	}

	//循环到列表尾部
	tmp := this.Next
	for{
		if tmp.Next == nil {
			break
		}

		tmp = tmp.Next
	}


	for{
		if tmp.Prev == nil {
			break
		}
		fmt.Printf("[no:%v,name:%v,nickname:%v,prev:%p,next:%p]\n",tmp.No,tmp.Name,tmp.Nickname,tmp.Prev,tmp.Next)
		tmp = tmp.Prev
	}
}

func main() {
	head := &HeroNode{}

	node1 := &HeroNode{
		No: 1,
		Name: "node1",
		Nickname: "node1",
	}
	node2 := &HeroNode{
		No: 2,
		Name: "node2",
		Nickname: "node2",
	}
	node3 := &HeroNode{
		No: 3,
		Name: "node3",
		Nickname: "node3",
	}

	head.InsertByAsc(node2)
	head.InsertByAsc(node1)
	head.InsertByAsc(node3)

	//删除
	//head.Del(1)
	//head.Del(3)
	//head.Del(2)

	head.Each()
	fmt.Println("-------------------------")
	head.EachRevers()


}