单循环链表，不带头结点的go语言实现

package main


/*
不带头结点的单向循环链表
*/
import (
	"errors"
	"fmt"
)

type Node struct {
	key int
	value string
	next *Node
}

//创建一个新结点
func newNode(key int, value string)(newNode *Node) {
	 newNode = &Node{
		key :key,
		value: value,
		//next: newNode, 这样做指针还是为空的
	}
	newNode.next = newNode //这样做才能实现自己指向自己
	return newNode
}
//前面插入结点(其实就是每次插入第一个node后面)
func addNode(list ,newNode *Node) {
	newNode.next = list.next
	list.next = newNode
}

//展示链表
func showList(list *Node) {
	if list == nil {
		fmt.Println("链表为空")
		return
	}
	tmp := list
	for  {
		fmt.Printf("key:%d,value:%s",tmp.key,tmp.value)
		tmp = tmp.next
		if tmp == list {
			break
		}
	}
	fmt.Println()
}

//按值删除  指针是浅拷贝的，如果被删除的是第一个结点，以后遍历的时候就会出现错误，所以需要返回值，返回新的第一个结点
func delByValue(list *Node, key int) (reslist *Node,err error){
	//定义一个跑龙套
	reslist = list
	tmp := list
	i := 1
	for {
		if tmp.next.key == key {
			if tmp.next== list {
				//删除的是第一个结点
				reslist = list.next
			}
			tmp.next = tmp.next.next
			return
		}
		tmp = tmp.next
		if tmp == list {
			//遍历完了链表
			break
		}
		i++
	}
	//跑到这里证明链表中没有对于的key
	err = errors.New("链表中没有对于的key")
	return
}

//主函数测试上面结构
func main() {
	node1 := newNode(10,"100")
	//fmt.Printf("node1:%#v,node1 address:%p, node1.next:【%p】\n",node1,node1,node1.next)
	node2 := newNode(20,"200")
	node3 := newNode(30,"300")
	node4 := newNode(40,"400")
	addNode(node1,node2)
	showList(node1)
	addNode(node1,node3)
	showList(node1)
	addNode(node1,node4)
	showList(node1)

	node1, err := delByValue(node1,10)
	if err != nil{
		fmt.Println(err)
		return
	}
	fmt.Println("===================")
	showList(node1)
	
}