Golang 实现单向环形链表

最新推荐文章于 2023-12-30 00:00:00 发布
最新推荐文章于 2023-12-30 00:00:00 发布
阅读量318 收藏 1
点赞数 1
分类专栏： 数据结构&算法 文章标签： 链表 数据结构 算法 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a451343010/article/details/111761598
版权

单向环形链表

单向环形链表是一种特殊的单向链表。

单向链表最后一个节点的 Next 指针指向空。

而单向环形链表最后一个节点的 Next 指针指向头节点。

如图所示：

 

单向环形链表节点的构建

假设把几只猫的信息（编号、名字）构成一个单向环形链表。

Golang 代码：

type CatNode struct {
	no   int      // 猫的编号
	name string   // 猫的名字
	next *CatNode // 指向下一只猫的指针
}

 

往单向环形链表中插入节点

不按照编号顺序，新节点直接插入尾部。

Golang 代码：

// 无序地往单向环形链表添加节点
func InsertCircleNode(head *CatNode, newNode *CatNode) {

	// 判断进来的新节点，是不是第一个节点
	// 由于单向环形链表没有 head 节点
	// 因此默认第一个进来的节点为头节点
	if head.next == nil {
		head.no = newNode.no
		head.name = newNode.name
		head.next = head
		return
	}

	// 进来的新节点，不是第一个节点
	temp := head

	// 寻找最后一个节点
	for temp.next != head {
		temp = temp.next
	}

	newNode.next = head
	temp.next = newNode

}

 

按照编号，有序地往单向环形链表中插入节点

Golang 代码：

// 按照编号, 有序地往单向环形链表中加入节点
func InsertCircleNodeByOrder(head *CatNode, newNode *CatNode) *CatNode {

	// 辅助节点
	temp := head
	// 辅助指针，永远指向单向环形队列的尾部
	tail := head

	// 新节点进来时，单向环形链表为空
	// 则让第一个节点为头节点，构成自循环
	if head.next == nil {
		head.name = newNode.name
		head.no = newNode.no
		head.next = head
		return head
	}

	// 新节点进来时，单向环形链表中只有一个自循环的节点
	if temp.next == head {

		head.next = newNode
		newNode.next = head

		// 比较 newNode 和头节点的id大小
		// 如果新节点的id较小，则称为头节点
		if newNode.no < temp.no {
			head = newNode
		}

	} else { // 单向环形链表有两个及以上的节点

		// 让 tail 指向尾部节点
		for tail.next != head {
			tail = tail.next
		}

		// 如果新节点的 no 小于头节点
		// 让新节点成为头节点
		if head.no > newNode.no {
			newNode.next = head
			tail.next = newNode
			head = newNode
			return head
		}

		// 如果新节点大于头节点
		// 循环地在单向环形链表中找到适合插入新节点的位置
		flag := false
		for {

			if temp.no == newNode.no {
				break
			}

			// 如果循环到了单向环形链表的尾部
			// 新节点的 no 大于单向环形链表的任何一个节点
			// 因此把新节点插入到单向环形链表的尾部
			if temp.next == head {
				flag = true
				break
			}
            
            // 找到了适合插入新节点的位置
			if temp.next.no > newNode.no {
				flag = true
				break
			}
            
            // 继续访问下一个节点
			temp = temp.next

		}

		if flag {

			newNode.next = temp.next
			temp.next = newNode

		} else {
			fmt.Printf("编号为 %d 的节点已经存在,无法插入\n", newNode.no)
		}

	}

	return head

}

 

根据编号，删除单向环形链表中的某个节点

Golang 代码：

// 删除环形单向链表的节点
func DelCircleNode(head *CatNode, id int) *CatNode {

	temp := head
	helper := head
	if temp.next == nil {
		fmt.Println("the link list is empty")
		return head
	}

	// 假设环形链表就只有一个节点
	if temp.next == head {
		temp.next = nil
		return head
	}

	// 将 helper 定位到环形链表的最后
	for {

		if helper.next == head {
			break
		}

		helper = helper.next

	}

	// 链表有两个以上的节点
	flag := true
	for {

		// 说明到了最后一个节点，还没有找到删除的节点
		if temp.next == head {
			break
		}

		if temp.no == id {
			// 如果删除的是头节点
			if temp == head {
				head = head.next

			}
			helper.next = temp.next
			fmt.Printf("\n删除的猫 = %d\n", id)
			flag = false
			break
		}

		// 移动，用来比较 id 和节点的 no
		temp = temp.next
		// 移动，一旦找到要删除的节点
		helper = helper.next

	}

	// 这里还需要再比较一次
	if flag {
		if temp.no == id {
			helper.next = temp.next
			fmt.Printf("删除的猫 = %d\n", id)
		} else {
			fmt.Printf("没有找到需要删除的节点：%d\n", id)
		}
	}

	return head

}

 

显示单向环形链表

Golang 代码：

// 显示单向环形链表的节点
func ListCircleNode(head *CatNode) {

    fmt.Println("\n单向环形链表的信息如下============")

	temp := head

	for {
		fmt.Printf("[%d] %s => ", temp.no, temp.name)
		if temp.next == head {
			break
		}

		temp = temp.next

	}

}

 

完整代码

/*
	数据结构
	单向环形链表
*/
package main

import "fmt"

type CatNode struct {
	no   int      // 猫编号
	name string   // 猫的名字
	next *CatNode // 下一个猫
}

// 无序地往环形链表添加节点
func InsertCircleNode(head *CatNode, newNode *CatNode) {

	// 判断进来的新节点，是不是第一个节点
	// 由于单向环形链表没有 head 节点
	// 因此默认第一个进来的节点为头节点
	if head.next == nil {
		head.no = newNode.no
		head.name = newNode.name
		head.next = head
		return
	}

	// 进来的新节点，不是第一个节点
	temp := head

	// 寻找最后一个节点
	for temp.next != head {
		temp = temp.next
	}

	newNode.next = head
	temp.next = newNode

}

// 按照 no, 有序地往环形链表中加入节点
func InsertCircleNodeByOrder(head *CatNode, newNode *CatNode) *CatNode {

	// 辅助节点
	temp := head
	// 辅助指针，永远指向单向环形队列的尾部
	tail := head

	// 新节点进来时，单向环形链表为空
	// 则让第一个节点为头节点，构成自循环
	if head.next == nil {
		head.name = newNode.name
		head.no = newNode.no
		head.next = head
		return head
	}

	// 新节点进来时，单向环形链表中只有一个自循环的节点
	if temp.next == head {

		head.next = newNode
		newNode.next = head

		// 比较 newNode 和头节点的id大小
		// 如果新节点的id较小，则称为头节点
		if newNode.no < temp.no {
			head = newNode
		}

	} else { // 单向环形链表有两个及以上的节点

		// 让 tail 指向尾部节点
		for tail.next != head {
			tail = tail.next
		}

		// 如果新节点的 no 小于头节点
		// 让新节点成为头节点
		if head.no > newNode.no {
			newNode.next = head
			tail.next = newNode
			head = newNode
			return head
		}

		// 如果新节点大于头节点
		// 循环地在单向环形链表中找到适合插入新节点的位置
		flag := false
		for {

			if temp.no == newNode.no {
				break
			}

			// 如果循环到了单向环形链表的尾部
			// 新节点的 no 大于单向环形链表的任何一个节点
			// 因此把新节点插入到单向环形链表的尾部
			if temp.next == head {
				flag = true
				break
			}

			if temp.next.no > newNode.no {
				flag = true
				break
			}

			temp = temp.next

		}

		if flag {

			newNode.next = temp.next
			temp.next = newNode

		} else {
			fmt.Printf("编号为 %d 的节点已经存在,无法插入\n", newNode.no)
		}

	}

	return head

}

// 删除环形单向链表的节点
func DelCircleNode(head *CatNode, id int) *CatNode {

	temp := head
	helper := head
	if temp.next == nil {
		fmt.Println("the link list is empty")
		return head
	}

	// 假设环形链表就只有一个节点
	if temp.next == head {
		temp.next = nil
		return head
	}

	// 将 helper 定位到环形链表的最后
	for {

		if helper.next == head {
			break
		}

		helper = helper.next

	}

	// 链表有两个以上的节点
	flag := true
	for {

		// 说明到了最后一个节点，还没有找到删除的节点
		if temp.next == head {
			break
		}

		if temp.no == id {
			// 如果删除的是头节点
			if temp == head {
				head = head.next

			}
			helper.next = temp.next
			fmt.Printf("\n删除的猫 = %d\n", id)
			flag = false
			break
		}

		// 移动，用来比较 id 和节点的 no
		temp = temp.next
		// 移动，一旦找到要删除的节点
		helper = helper.next

	}

	// 这里还需要再比较一次
	if flag {
		if temp.no == id {
			helper.next = temp.next
			fmt.Printf("删除的猫 = %d\n", id)
		} else {
			fmt.Printf("没有找到需要删除的节点：%d\n", id)
		}
	}

	return head

}

// 显示单向环形链表的节点
func ListCircleNode(head *CatNode) {

    fmt.Println("\n单向环形链表的信息如下============")

	temp := head

	for {
		fmt.Printf("[%d] %s => ", temp.no, temp.name)
		if temp.next == head {
			break
		}

		temp = temp.next

	}

}

func main() {

	head := &CatNode{}

	node1 := &CatNode{
		no:   1,
		name: "Carfield",
	}

	node2 := &CatNode{
		no:   2,
		name: "American Shorthair",
	}

	node3 := &CatNode{
		no:   3,
		name: "Bule Cat",
	}

	InsertCircleNode(head, node1)
	InsertCircleNode(head, node2)
	InsertCircleNode(head, node3)
	head = DelCircleNode(head, 1)
	ListCircleNode(head)

	// 测试有序插入新节点
	head2 := &CatNode{}

	node4 := &CatNode{
		no:   4,
		name: "Cat4",
	}

	node5 := &CatNode{
		no:   5,
		name: "Cat5",
	}

	node33 := &CatNode{
		no:   3,
		name: "Cat33",
	}

	node66 := &CatNode{
		no:   6,
		name: "Cat66",
	}

	node88 := &CatNode{
		no:   88,
		name: "Cat88",
	}

	node7 := &CatNode{
		no:   7,
		name: "Cat7",
	}

	node77 := &CatNode{
		no:   7,
		name: "Cat77",
	}

	node22 := &CatNode{
		no:   2,
		name: "Cat22",
	}

	fmt.Println("\n有序地显示节点============")
	head2 = InsertCircleNodeByOrder(head2, node5)
	head2 = InsertCircleNodeByOrder(head2, node4)
	head2 = InsertCircleNodeByOrder(head2, node33)
	head2 = InsertCircleNodeByOrder(head2, node66)
	head2 = InsertCircleNodeByOrder(head2, node88)
	head2 = InsertCircleNodeByOrder(head2, node7)
	head2 = InsertCircleNodeByOrder(head2, node77)
	head2 = InsertCircleNodeByOrder(head2, node22)
	ListCircleNode(head2)

	// 测试删除有序环形链表
	head2 = DelCircleNode(head2, 6)
	ListCircleNode(head2)

	// 测试删除有序环形链表
	head2 = DelCircleNode(head2, 2)
	ListCircleNode(head2)

}

执行结果


删除的猫 = 1

单向环形链表的信息如下============
[2] American Shorthair => [3] Bule Cat => 
有序地显示节点============
编号为 7 的节点已经存在,无法插入

单向环形链表的信息如下============
[2] Cat22 => [3] Cat33 => [4] Cat4 => [5] Cat5 => [6] Cat66 => [7] Cat7 => [88] Cat88 =>
删除的猫 = 6

单向环形链表的信息如下============
[2] Cat22 => [3] Cat33 => [4] Cat4 => [5] Cat5 => [7] Cat7 => [88] Cat88 =>        
删除的猫 = 2

单向环形链表的信息如下============
[3] Cat33 => [4] Cat4 => [5] Cat5 => [7] Cat7 => [88] Cat88 =>

 

XPiedPiperX
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
python/golang实现循环链表的示例代码
09-16
主要介绍了python/golang如何实现循环链表，帮助大家更好的理解和学习循环链表的实现方法，感兴趣的朋友可以了解下
237. 删除链表中的节点
Duck_Duck_的博客
09-14 169
难度：简单 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为要被删除的节点。 现有一个链表 --head =[4,5,1,9]，它可以表示为: 示例 1： 输入：head = [4,5,1,9], node = 5 输出：[4,1,9] 解释：给定你链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2： 输入：head = [4,5,1,9], node = 1 输出：...
go实现循环链表
空山新雨后，天气晚来秋
03-02 963
go实现循环链表
Go语言_数据结构_环形单向链表的实现
热门推荐
数据知道的博客
07-11 2万+
完成对单向环形链表的添加节点，删除节点和显示。 代码如下： package main import ( "fmt" ) //定义猫的结构体结点 type CatNode struct { no int //猫猫的编号 name string next *CatNode } func InsertCatNode(head *CatNode, newCatNode *CatNode) { ...
数据结构之GO实现环形链表
weixin_43318506的博客
05-18 287
循环链表原理如下图所示： Go语言代码实现如下： package main import ( "fmt" ) //定义猫的结构体结点 type DogNode struct { no int //狗的编号 name string //狗的名字 next *DogNode //指向下一个节点 } func InsertDogNode(head *CatNode, newCatNode *CatNode) { //判断是不是添加第一只狗 if head.next == nil {
Go---环形链表
weixin_47328424的博客
01-28 839
完成对单向环形链表的添加结点，册除结点和显示. package main import ( "fmt" ) //定义猫的结构体的结点 type CatNode struct { Num int //猫的编号 Name string Next *CatNode //指向下一个结点 } //添加结点 func InsertCatNode(head *CatNode,newCatNode *CatNode){ //判断是不是添加第一只猫 ...
golang-链表
01-08
链表的实现 1.1 代码 package Algorithm import ( _ container/list errors fmt ) type Node struct { data interface{} pre *Node next *Node } type List struct { head *Node tail *Node length uint64...
golang环形队列实现代码示例
09-18
主要介绍了golang环形队列实现代码示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang中单向channel的语法介绍
09-21
通过消息来共享数据是golang的一种设计哲学，channel则是这种哲理的体现。下面这篇文章主要给大家介绍了关于golang中单向channel语法的相关资料，文中通过示例代码介绍的非常详细，需要的朋友们下面来一起看看吧。
golang双链表的实现代码示例
09-18
主要介绍了golang双链表的实现代码示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
数据结构【Golang实现】(二)——循环链表
脑袋装水的博客
03-13 381
《Go语言》实现循环链表
＜ 每日算法：一文带你认识 “ 双指针算法 ” ＞
一个平平无奇的技术宅
06-07 781
`双指针`并非指的是一种具体的公式或者范式。而是一种运算思路，用于节省逻辑运算时间的`逻辑思路`！双指针算法通常用于`优化时间复杂度`！
前端leetcde算法面试套路之双指针
js2030code的博客
11-02 156
上一 part 刚写完二分和滑窗，他们都属于特殊的双指针方法，所以这一 part 直接汇总一下除了特殊的二分和滑窗外的其他双指针写法这里主要是快慢指针和端点指针， 解决一些一次遍历搞不掂，多个指针协商干活不累的题目，基本上觉得属于一种解题上的思路，一次不行，我就两次的样子；所以刷完基础双指针，然后滑窗和二分后，这种思路在今后解题上应该会不定期能冒出来吧；所以下期学习另外一种解题思路，回溯吧；
golang 单向环形链表增、删
不忘初心，方得始终
06-04 71
【代码】golang 单向环形链表增、删。
前端算法之双指针
BradenHan的专栏
12-30 1032
双指针是一种编程技术，通常用于解决数组或链表的问题。双指针法使用两个指针（通常称为快指针和慢指针）来遍历数据结构，以解决一些需要找到特定元素或进行其他复杂操作的问题。双指针法的主要优点是它可以在一次遍历中解决问题，而不需要反向遍历或使用其他额外的数据结构。这使得它在解决一些问题时效率更高。例如： 在一个数组中查找两个数之和等于一个特定值，我们可以使用双指针法。首先，我们可以将一个指针放在数组的开头，另一个指针放在数组的末尾。然后，我们可以将两个指针向中间移动，比较它们所指向的元素之和与目标值的大小关系。请注
golang解决约瑟夫问题，单向循环链表实现
走在架构师的路上
07-31 334
据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最.
Go-实现单向循环链表
luyaran的博客
08-28 214
代码片段如下： /* * .::::. * .::::::::. * ::::::::::: * ..:::::::::::' * '::::::::::::' * .:::::::::: * '::::::::::::::.. * ..::::::::::::. Utils:单
GO单向环形循环链表
m0_50377559的博客
08-27 378
GO单向环形循环链表 // 单向环形链表 结构体 韩磊 201916010619 package main import ( "fmt" ) type CatNode struct {//定义猫的结构体结点 no int //猫猫的编号 name string id int //加入链表的编号 next *CatNode } //全局 环形链表 初始元素 桥梁元素 var first = &CatNode{} var t = &CatNode{} va
go语言数据结构第五篇-链表（单向环形链表）
junaozun的博客
04-21 399
单向环形链表应用场景 约瑟夫问题： 设编号为1,2,3，....，n的n个人围做一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此产生一个出队编号的序列。 思路：用一个不带头节点的单向环形链表，先构成一个有n个节点的单向循环链表，然后由k节点起从1开始计数，将计到m的那个节点...
golang实现函数
最新发布
03-02
下面是介绍Golang实现函数的几个关键点： 1. 函数定义：使用关键字`func`来定义函数，语法如下： ``` func 函数名(参数列表) 返回值列表 { // 函数体 } ``` 例如，定义一个计算两个整数之和的函数： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值