golang实现单向，双向，环形单向链表：增（两种方式）删改查，链表所有结点展示...双向链表，环形单项链表完整代码

已于 2023-08-11 19:13:21 修改
阅读量383 收藏
点赞数
分类专栏： go 文章标签： golang 链表 数据结构
于 2023-08-10 19:16:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31501115/article/details/132214237
版权

golang单项链表

  1. 头部代码：引用一些包，创建链表数据结构
package utils
import (
	"fmt"
)
//单链表 末尾添加
type SingleNode struct{
	No int //编号
	Name string //名称
	Next *SingleNode //表示指向下一个节点
}
  1. 增加：分为两种，第二种比较常用

第一种添加：

//链表插入一个节点
//第一种添加：在单链表的最后加入
func AddSingleNode(head *SingleNode, newSingleNode *SingleNode){
	//1.先找到链表的最后这个节点
	//2.创建一个辅助节点
	temp := head
	for{
		if temp.Next == nil{//找到最后一个
			break
		}
		temp = temp.Next //不断的移动指向下一个结点
	}

	//3.将newSingleNode 加入链表的最后
	temp.Next = newSingleNode

	return
}

第二种添加（常用）：

//第二种添加：根据no的编号从小到大插入,编号是唯一的
func InsertSingleNode(head *SingleNode, newSingleNode *SingleNode){
	//1.找到恰当的节点
	//2.创建一个辅助节点
	temp := head
	flag := true //默认可以插入链表

	//让插入的节点的no,和temp的下的一个节点no进行比较
	for{
		if temp.Next == nil{
			break
		}else if temp.Next.No > newSingleNode.No{//排序；说明newSingleNode应该插入temp后面【如果编号有相等的，需要修改为：temp.No >= newSingleNode.No】
			break
		}else if temp.Next.No == newSingleNode.No{//说明这个链表已经存在这个No，不能插入
			flag = false
			break
		}

		temp = temp.Next
	}

	if !flag{
		fmt.Println("该编号已经存在，不能插入")
		return
	}else{
		newSingleNode.Next = temp.Next
		temp.Next = newSingleNode
	}

	return
}
  1. 删除 ：删除传入No的结点
//删除No= id的结点
func DeleteSingleNode(head *SingleNode, id int){
	temp := head
	flag := true //代表找到

	//找到要删除的节点
	for{
		if temp.Next.No == id{
			break
		}else if temp.Next == nil{//找到最后一个节点
			flag = false
			break
		}else{
			temp = temp.Next
		}

	}

	if flag{
		temp.Next = temp.Next.Next
		fmt.Println("delete ok...")
	}else{
		fmt.Printf("要删除对应id=%d的链表不存在\n", id)
	}
	return
}
  1. 修改 ：修改对应No的节点信息
//修改No=id的结点的SingleNode
func EditSingleNode(head *SingleNode, id int, newSingleNode *SingleNode){
	temp := head
	flag := false

	for{
		if temp.Next == nil{
			//已经找到结尾未找到
			break
		}else if temp.Next.No == id{//找到
			flag = true
			break
		}else{
			temp = temp.Next
		}
	}

	if flag{
		newSingleNode.Next = temp.Next.Next
		temp.Next = newSingleNode
		return
	}

	fmt.Println("抱歉，修改失败，未找到该结点")
	return
	
}
  1. 查询：查询对应No的结点
//查找No= id的节点
func FindSingleNode(head *SingleNode, id int){
	temp := head
	flag := false

	for{
		if temp.Next == nil{
			//已经找到结尾未找到
			break
		}else if temp.Next.No == id{
			flag = true
			break
		}else{
			temp = temp.Next
		}
	}

	if flag{
		fmt.Printf("恭喜，找到了对应id=%d的节点：[%d, %s]", id, temp.Next.No, temp.Next.Name)
		fmt.Println()
		return
	}

	fmt.Println("抱歉，未找到该节点")
	return
	
}
  1. 所有结点展示：遍历展示链表的所有结点
//显示链表的所有节点信息
func ListSingleNode(head *SingleNode){
	//创建一个辅助节点 
	temp := head

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

	for{
		fmt.Printf("[%d, %s] ==>", temp.Next.No, temp.Next.Name)
		temp = temp.Next
		if temp.Next == nil{//已经到达尾部
			break
		}	
	}
	fmt.Println()
	return
}
  1. 测试增删改查：主要测试第二种添加。单链表封装在文件夹utils下，而在main包下进行的调用测试
//创建一个头节点
    head := &utils.SingleNode{}
    single1 := &utils.SingleNode{
        No : 1,
        Name : "张三",
    }

    single4 := &utils.SingleNode{
        No : 3,
        Name : "王五",
    }

    single2 := &utils.SingleNode{
        No : 2,
        Name : "王麻子",
    }
    single3 := &utils.SingleNode{
        No : 4,
        Name : "旺财",
    }

    updateSingle := &utils.SingleNode{
        No : 2,
        Name : "李四",
    }

    utils.InsertSingleNode(head, single1)
    utils.InsertSingleNode(head, single4)
    utils.InsertSingleNode(head, single2)
    utils.InsertSingleNode(head, single3)

    utils.ListSingleNode(head)//原始链表 `预期结果`：[1, 张三] ==>[2, 王麻子] ==>[3, 王五] ==>[4, 旺财] ==>
    utils.FindSingleNode(head, 2)//查找对应id的链表
    utils.EditSingleNode(head, 2, updateSingle)//修改id=2的结点
    utils.ListSingleNode(head)//修改后的结点链表 `预期结果`：[1, 张三] ==>[2, 李四] ==>[3, 王五] ==>[4, 旺财] ==>
    utils.DeleteSingleNode(head, 2)//删除对应id链表
    utils.ListSingleNode(head) //删除后最新的链表  `预期结果`：[1, 张三] ==>[3, 王五] ==>[4, 旺财] ==>
  1. 结果
# 执行 utils.ListSingleNode(head)
[1, 张三] ==>[2, 王麻子] ==>[3, 王五] ==>[4, 旺财] ==> 
# 执行 utils.FindSingleNode(head, 2)
恭喜，找到了对应id=2的节点：[2, 王麻子]
# 执行 utils.EditSingleNode(head, 2, updateSingle)
恭喜，更新了对应id=2的节点：[2, 李四]
# 执行 utils.ListSingleNode(head)
[1, 张三] ==>[2, 李四] ==>[3, 王五] ==>[4, 旺财] ==>
# 执行 utils.DeleteSingleNode(head, 2)
delete ok...
# 执行 utils.ListSingleNode(head)
[1, 张三] ==>[3, 王五] ==>[4, 旺财] ==>

测试执行结果截图：
执行结果截图
9. 双向链表完整代码

package utils

import (
	"fmt"
)


type DoubleNode struct{
	No int
	Name string
	Pre *DoubleNode  //前一个节点
	Next *DoubleNode //后一个节点
}

//链表插入一个节点
//第一种添加：在单链表的最后加入
func AddDoubleNode(head *DoubleNode, newDoubleNode *DoubleNode){
	//1.先找到链表的最后这个节点
	//2.创建一个辅助节点
	temp := head
	for{
		if temp.Next == nil{//找到最后一个
			break
		}
		temp = temp.Next //不断的移动指向下一个结点
	}

	//3.将newDoubleNode 加入链表的最后
	temp.Next = newDoubleNode
	newDoubleNode.Pre = temp

	return
}

//第二种添加：根据no的编号从小到大插入,编号是唯一的
func InsertDoubleNode(head *DoubleNode, newDoubleNode *DoubleNode){
	//1.找到恰当的节点
	//2.创建一个辅助节点
	temp := head
	flag := true //默认可以插入链表

	//让插入的节点的no,和temp的下的一个节点no进行比较
	for{
		//temp.Next = nil表示已到最后一个结点 || 排序；说明newDoubleNode应该插入temp后面【如果编号有相等的，需要修改为：temp.No >= newDoubleNode.No】
		if temp.Next == nil || temp.Next.No > newDoubleNode.No{ 
			break
		}else if temp.Next.No == newDoubleNode.No{//说明这个链表已经存在这个No，不能插入
			flag = false
			break
		}

		temp = temp.Next
	}

	if flag{
		newDoubleNode.Next = temp.Next
		newDoubleNode.Pre = temp

		if(temp.Next != nil){//判断是否为最后一个链表结点
			temp.Next.Pre = newDoubleNode
		}
		temp.Next = newDoubleNode
	}else{
		fmt.Println("该编号已经存在，不能插入")
	}

	return
}


//修改No=id的结点的DoubleNode
func EditDoubleNode(head *DoubleNode, id int, updateDoubleNode *DoubleNode){
	temp := head
	flag := false

	for{
		if temp.Next == nil{
			//已经找到结尾未找到
			break
		}else if temp.Next.No == id{//找到
			flag = true
			break
		}

		temp = temp.Next
	}

	if flag{
		updateDoubleNode.Next = temp.Next.Next
		temp.Next = updateDoubleNode
		
		if temp.Next != nil{
			updateDoubleNode.Pre = temp.Pre
		}
		return
	}

	fmt.Println("抱歉，修改失败，未找到该结点")
	return
	
}


//删除No= id的结点[双向链表的自我结点删除]
func DeleteDoubleNode(head *DoubleNode, id int){
	temp := head
	flag := true //代表找到

	//找到要删除的节点
	for{
		if temp.Next.No == id{
			break
		}else if temp.Next == nil{//找到最后一个节点
			flag = false
			break
		}else{
			temp = temp.Next
		}

	}

	if flag{
		temp.Next = temp.Next.Next
		if temp.Next != nil{//判断是否为最后一个链表结点
			temp.Next.Pre = temp
		}
		fmt.Println("delete ok...")
	}else{
		fmt.Printf("要删除对应id=%d的链表不存在\n", id)
	}
	return
}


//显示链表的所有节点信息:正向打印
func ListDoubleNode(head *DoubleNode){
	//创建一个辅助节点 
	temp := head

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

	fmt.Println("正向打印链表结点:")
	for{
		fmt.Printf("[%d, %s] ==>", temp.Next.No, temp.Next.Name)
		temp = temp.Next
		if temp.Next == nil{//已经到达尾部
			break
		}	
	}

	return
}

//显示链表的所有节点信息:逆向打印
func DescListDoubleNode(head *DoubleNode){
	//创建一个辅助节点 
	temp := head

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

	//先找到最后一个结点
	for{
		if temp.Next == nil{
			break
		}
		temp = temp.Next
	}

	//此时temp以是正向数最后一个结点
	fmt.Println("逆向打印链表结点：") 
	for{
		fmt.Printf("[%d, %s] ==>", temp.No, temp.Name)

		temp = temp.Pre
		if temp.Pre == nil{//已经到达首部结点
			break
		}	
	}
	return
}
  1. 环形单项链表：需要注意删除首结点时要从新接收这个返回值,获取列表时传入新接收到的head
package utils

import (
	"fmt"
)

type CricleSingleNode struct{
	No int
	Name string
	Next *CricleSingleNode
}


func InsertCricleSingleNode(head *CricleSingleNode, newNode *CricleSingleNode){
	//判断是否为第一个结点
	if head.Next == nil{
		head.No = newNode.No
		head.Name = newNode.Name
		head.Next = head //一个结点时也要是环形

		return
	}

	//定义临时变量，找到环形的最后一个结点
	tempNode := head
	for{
		if tempNode.Next == head{
			break
		}
		tempNode = tempNode.Next
	}

	tempNode.Next = newNode
	newNode.Next = head

	return

}


//输出环形链表所有结点
func ListCricleSingleNode(head *CricleSingleNode){
	tempNode := head
	if tempNode.Next == nil{//是一个空链表
		fmt.Println("这是一个空的环形链表")
		return
	}
	for{
		fmt.Printf("[No = %d, Name = %s]-->", tempNode.No, tempNode.Name)
		if tempNode.Next == head{//头和尾相遇了
			fmt.Printf("[No = %d, Name = %s]", tempNode.Next.No, tempNode.Next.Name)
			break
		}
		tempNode = tempNode.Next
	}
	fmt.Println()
	return
}

//删除环形链表的某一结点【需要注意删除首结点时要从新接收这个返回值,获取列表时传入新接收到的head】
func DeleteCricleSingleNode(head *CricleSingleNode, id int) *CricleSingleNode{

	tempNode := head //指向环形首部
	if tempNode == nil{
		fmt.Println("这是一个空的环形链表")
		return head
	}
	//如果只有一个结点
	if tempNode.Next == head{
		tempNode.Next = nil
		return head
	}

	//将helper 定位到最后
	helpNode := head //指向环形尾部
	for {
		if helpNode.Next == head{
			break
		}
		helpNode = helpNode.Next
	}

	flag := false //删除了
	for{
		if tempNode.Next == head{//找到了最后一个
			flag = true //到结尾了还没删除
			break
		}

		if tempNode.No == id {
			if tempNode == head{//删除的是头部
				head = head.Next
			}
			helpNode.Next = tempNode.Next
			return head
		}

		tempNode = tempNode.Next
		helpNode = helpNode.Next
	}

	if flag{
		if tempNode.No == id{
			helpNode.Next = tempNode.Next
		}else{
			fmt.Println("没有找到要删除的结点")
		}
	}

	return head

}

环形链表测试代码截图示例：注意红色箭头指向部分
在这里插入图片描述

程序员D日常
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Golang数据结构-环形链表
qq_43498850的博客
04-01 301
文章目录一、Golang数据结构-环形链表1.基本介绍二、使用步骤1.使用一个结构体管理单链表2.添加链表数据3.显示链表的所有结点信息4.删除链表数据5.编写一个主函数测试三、运行结果 一、Golang数据结构-环形链表 1.基本介绍 环形链表的元素由一个或多个Ring结构体组成，每一个代表环形链表的一个元素，但它同时也代表链表本身。环形链表没有头尾；指向环形链表任一元素的指针都可以作为整个环形链表看待。由此可以看出，环形链表没有实体，多个元素组合在一起就是一个环形链表，每一个元素成员都可以代表环..
golang标准库-环形链表(ring)
热门推荐
itpika的博客
06-01 1万+
Ring类型代表环形链表的一个元素，同时也代表链表本身。环形链表没有头尾；指向环形链表任一元素的指针都可以作为整个环形链表看待。Ring零值是具有一个（Value字段为nil的）元素的链表。
Golang 链表实现
weixin_44558408的博客
07-04 1081
Golang本身自带实现list的基本库：container/list；具体使用方法，可以查看Go基础库文档：https://studygolang.com/pkgdoc下面是不适用基础库的实现方法，优化方式有很多，实现思路仅供参考：下文实现了单向链表、循环链表、双向链表，单链表是基础，其他的链表基本都是根据单链表演化的。先把代码贴上，后续分解代码： 3.2 增删改查图示： 链表操作主要分为：增、删、改、查； 根据实现过程，增删操作类似、改查操作类似增加和删除增加节点： 步骤：① 创建插入的节点，找到
golang实现链表
李三思的博客
07-16 471
golang实现链表
Go语言(Golang)环形链表
weixin_33979203的博客
12-07 356
package main import ( "fmt" ) //环形链表测试用结构体 type TestNode struct { no int //编号 name string //姓名 next *TestNode } //环形链表插入 func InsertNod(head *TestNode, newNode *TestNode) { ...
go语言通过数组和链表的方式实现队列 数组和链表.pdf
04-18
"go语言通过数组和链表的方式实现队列" 从给定的文件信息中，我们可以生成以下知识点： 1.队列的定义：队列是一种特殊的线性表，只能在队列的尾部添加元素，在队列的头部删除元素，先进先出（FIFO）。 2.go语言中...
python/golang实现循环链表的示例代码
09-16
循环链表是一种特殊的链式数据结构，它与普通单链表的主要区别在于最后一个节点的`next`指针不是`None`或`nil`，而是指向链表的第一个节点，形成了一个环形结构。这种数据结构在某些算法和场景中非常有用，例如在...
golang双链表的实现代码示例
09-18
在本文中，我们将深入探讨Golang中的双链表实现，这是一种数据结构，允许在列表的头部和尾部进行高效的插入和删除操作。双链表的特点是每个节点不仅包含数据，还包含指向其前一个和后一个节点的指针，这使得双向遍历...
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...
go学习 --- 环形链表
qq_46093575的博客
02-23 406
一、环形链表 package main import ( "container/ring" "fmt" ) func main() { r := ring.New(5) for i := 0; i < 5; i++ { r.Value = i r = r.Next() //循环下一个 } r.Do(func(i interface{}) { fmt.Println(i) }) r3 := r.Move(3) //删除第三个元素 fmt.Println(r3) f
环形链表(go实现
dengjiayue的博客
03-12 143
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。仅仅是为了标识链表的实际情况。链接：https://leetcode.cn/problems/linked-list-cycle。如果链表中存在环 ，则返回 true。否则，返回 false。著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。给你一个链表的头节点 head ，判断链表中是否有环。
数据结构【Golang实现】(二)——循环链表
脑袋装水的博客
03-13 426
《Go语言》实现循环链表
golang 单链表的实现增删改查
不忘初心，方得始终
05-15 166
【代码】golang 单链表的实现增删改查。
Go标准库学习笔记-循环链表 (container/ring)
preyta的专栏
04-26 1556
概述 Ring是一种循环链表结构，没有头尾，从任意一个节点出发都可以遍历整个链。其定义如下，Value表示当前节点的值： type Ring struct { Value interface{} } 类型方法 New Ring.New用于创建一个新的Ring，接收一个整形参数，用于初始化Ring的长度，其方法定义如下： func New(n int) ...
golang中container/ring包用法
chenbaoke的专栏
11-11 5277
ring包实现了环形链表的操作。   type Ring  //Ring类型代表环形链表的一个元素，同时也代表链表本身。环形链表没有头尾；指向环形链表任一元素的指针都可以作为整个环形链表看待。Ring零值是具有一个（Value字段为nil的）元素的链表。 type Ring struct { Value interface{} // 供调用者使用，本包不会对该值进行操
循环链表实例GO语言实现
tangguangqiang的博客
01-02 1212
package main import ( "fmt" "os" ) type Node struct{ data int pNext *Node } func initList() *Node{ pHead:=new(Node) pHead.pNext=pHead return pHead //返回头指针 } //创建尾指针的单循环链表 func createList(l
基于golang对链表的简单实现和理解
u014265398的博客
05-15 1049
最近在学习golang中的链表，记录一下学习，golang中没有java、php中的类，只有通过C语言吸收过来的struct这个类型，不过有类似的功能: 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个...
在Go中理解栈和先进先出原则
jzpfbpx的博客
08-16 200
在本博文中，我们将探讨如何在 Go 中实现和使用堆栈，以及堆栈如何遵循先进先出 (FIFO) 原则。Push方法将一个新的元素追加到片段的末尾，而Pop方法则从片段中删除并返回最后一个元素。堆栈的主要特点是遵循后进先出（LIFO）原则：最后一个添加到堆栈的元素是第一个被移除的元素。当我们运行这段代码时，我们可以看到元素从堆栈中移除的顺序与添加的顺序相反。当我们运行这段代码时，我们可以看到元素是按照添加的顺序从队列中移出的。使用堆栈实现队列的一种方法是使用两个堆栈：一个用于添加元素，另一个用于移除元素。
Go Roadmap-Basics中文笔记
最新发布
qq_51234298的博客
08-17 509
地址：https://roadmap.sh/golang简介：Github star No.6 学习路线 Go 中译版。
golang双向链表手动释放
11-25
在 Golang 中，手动释放双向链表需要注意以下几点： 1. 需要定义一个链表节点结构体，包含前驱节点和后继节点的指针，以及节点值等信息。 2. 需要定义一个链表结构体，包含链表头节点和链表长度等信息。 3. 在链表结构体中，需要定义一个互斥锁，用于保护链表的并发访问。 4. 在链表结构体中，需要定义一个释放节点的方法，该方法需要获取链表的互斥锁，然后遍历链表，释放每个节点的内存空间。 下面是一个示例代码，演示如何手动释放 Golang 双向链表： ```go package main import ( "fmt" "sync" ) type ListNode struct { prev *ListNode next *ListNode val int } type LinkedList struct { head *ListNode len int lock sync.Mutex } func (list *LinkedList) Release() { list.lock.Lock() defer list.lock.Unlock() node := list.head for node != nil { next := node.next node.prev = nil node.next = nil node = next } list.head = nil list.len = 0 } func main() { list := LinkedList{head: &ListNode{val: 1}, len: 1} list.head.next = &ListNode{prev: list.head, val: 2} list.len++ fmt.Println(list.head.val) fmt.Println(list.head.next.val) list.Release() fmt.Println(list.head) fmt.Println(list.len) } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员D日常

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值