第二课 golang数据结构和算法-链表

最新推荐文章于 2024-04-20 05:30:12 发布
最新推荐文章于 2024-04-20 05:30:12 发布
阅读量207 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa18855953229/article/details/108352965
版权

第二课 golang数据结构和算法-链表

tags:

  • golang
  • 2019尚硅谷

categories:

  • golang
  • 链表
  • 约瑟夫问题

文章目录

第一节 链表

1.1 链表介绍

  1. 链表是有序的列表，但是它在内存中是存储(不连续)如下：
    在这里插入图片描述

1.2 单向链表

  1. 单链表的示意图:
  2. 说明:一般来说，为了比较好的对单链表进行增删改查的操作，我们都会给他设置一个头结点，头结点的作用主要是用来标识链表头，本身这个结点不存放数据。
    在这里插入图片描述

1.3 单向链表的应用实例

  1. 使用带head头的单向链表实现–水浒英雄排行榜管理 案例的说明:
    • 完成对英雄人物的增删改查操作，删除和修改,查找
    • 第一种方法在添加英雄时，直接添加到链表的尾部
    • 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败并给出提示。
  2. 第一种方法代码实现：
package main
import (
	"fmt"
)

// 定义一个HeroNode
type HeroNode struct{
	no int // 编号
	name string // 名称
	nickname string // 花名
	next *HeroNode  //这个表示指向下一个节点
}

// 给链表插入一个节点
// 编写第一种插入方法, 在单链表的最后加入
func InsertHeroNode(head *HeroNode, newHeroNode *HeroNode){
	// 思路 1. 先找到该链表的最后这个节点
	// 2. 创建一个辅助节点 【用来帮忙的】
	temp := head
	for {
		if temp.next == nil{ //表示找到最后了
			break
		}
		temp = temp.next // 让temp不断的指向下一个节点
	}
	// 3. 加入到链表的最后 (现在temp已经位于链表末尾了)
	temp.next = newHeroNode
}
// 显示链表的所有节点信息
func ListHeroNode(head *HeroNode){
	// 1. 创建一个辅助节点 来帮忙 头节点不要动
	temp := head
	if temp.next == nil{
		fmt.Println("链表为空链表!")
		return 
	}

	// 2. 至少有一个节点 遍历这个链表
	for {
		fmt.Printf("[%d, %s, %s]==>", temp.next.no, 
		temp.next.name, temp.next.nickname)
		// 判读是否到链表尾部
		temp = temp.next
		if temp.next == nil{
			break
		}
	}
}
// 删除节点
func DelHeroNode(head *HeroNode, id int){
	temp := head
	flag := false
	for {
		if temp.next == nil{
			break
		}else if temp.next.no > id{
			break
		}else if temp.next.no == id{
			flag = true
			break
		}
		temp = temp.next
	}
	if !flag{
		fmt.Println("对不起，不存在no=", id)
		return
	}else{
		temp.next = temp.next.next
	}
}

func main(){
	// 1.先创建一个头节点
	head := &HeroNode{}
	// 2. 创建一个新的HeroNode
	hero1 := &HeroNode{
		no : 1,
		name : "宋江",
		nickname: "及时雨",
	}
	hero2 := &HeroNode{
		no : 2,
		name : "卢俊义",
		nickname: "玉麒麟",
	}
	hero3 := &HeroNode{
		no : 3,
		name : "林冲",
		nickname: "豹子头",
	}
	// 3. 加入一个节点
	InsertHeroNode(head, hero1)
	InsertHeroNode(head, hero2)
	InsertHeroNode(head, hero3)
	// 4. 显示
	ListHeroNode(head)
	fmt.Println()
	// 删除
	DelHeroNode(head, 2)
	ListHeroNode(head)

}
  1. 第二种方法实现:根据no 的编号从小到大插入…
// 给链表插入一个节点 拍好之后插入数据库 会节省很多order_by内存
// 编写第二种插入方法, 根据no 的编号从小到大插入..
func InsertHeroNode(head *HeroNode, newHeroNode *HeroNode){
	// 1. 找到适当的节点
	// 2. 创建一个辅助节点 【用来帮忙的】
	temp := head
	flag := true
	for {
		// 让插入节点的no 和temp的下一个节点的no 进行比较
		if temp.next == nil{ // 到链表的最后了
			break
		}else if temp.next.no > newHeroNode.no{
			// 说明newHeroNode 就应该插入到temp后面
			break
		}else if temp.next.no == newHeroNode.no{
			// 链表中已经有这个排名 不让插入
			flag = false
			break
		}
		temp = temp.next
	}
	if !flag{
		fmt.Println("对不起，已经存在no=", newHeroNode.no)
		return
	}else{
		// 3. 插入节点
		newHeroNode.next = temp.next
		temp.next = newHeroNode
	}
}

第二节 双向链表

2.1 双向链表介绍

  1. 单向链表的缺点分析
    • 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
    • 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp的下一个节点来删除的。
  2. 双向链表示意图
    在这里插入图片描述

2.2 双向链表应用实例

package main
import (
	"fmt"
)

// 定义一个HeroNode
type HeroNode struct{
	no int // 编号
	name string // 名称
	nickname string // 花名
	pre *HeroNode	// 这个表示指向前面一个节点
	next *HeroNode  //这个表示指向下一个节点
}

// 给双向链表插入一个节点
// 编写第一种插入方法, 在单链表的最后加入
func InsertHeroNode(head *HeroNode, newHeroNode *HeroNode){
	// 思路 1. 先找到该链表的最后这个节点
	// 2. 创建一个辅助节点 【用来帮忙的】
	temp := head
	for {
		if temp.next == nil{ //表示找到最后了
			break
		}
		temp = temp.next // 让temp不断的指向下一个节点
	}
	// 3. 加入到链表的最后 (现在temp已经位于链表末尾了)
	temp.next = newHeroNode
	newHeroNode.pre = temp
}
// 显示链表的所有节点信息
func ListHeroNode(head *HeroNode){
	// 1. 创建一个辅助节点 来帮忙 头节点不要动
	temp := head
	if temp.next == nil{
		fmt.Println("链表为空链表!")
		return 
	}

	// 2. 至少有一个节点 遍历这个链表
	for {
		fmt.Printf("[%d, %s, %s]==>", temp.next.no, 
		temp.next.name, temp.next.nickname)
		// 判读是否到链表尾部
		temp = temp.next
		if temp.next == nil{
			break
		}
	}
}
// 逆序打印链表的所有节点信息
func ListHeroNode1(head *HeroNode){
	temp := head
	if temp.next == nil{
		fmt.Println("链表为空链表!")
		return 
	}
	for {
		if temp.next == nil{
			break
		}
		temp = temp.next
	}

	for {
		fmt.Printf("[%d, %s, %s]==>", temp.no, 
		temp.name, temp.nickname)
		// 判读是否到链表尾部
		temp = temp.pre
		if temp.pre == nil{
			break
		}
	}
}

// 删除节点
func DelHeroNode(head *HeroNode, id int){
	temp := head
	flag := false
	for {
		if temp.next == nil{
			break
		}else if temp.next.no > id{
			break
		}else if temp.next.no == id{
			flag = true
			break
		}
		temp = temp.next
	}
	if !flag{
		fmt.Println("对不起，不存在no=", id)
		return
	}else{
		temp.next = temp.next.next
		if temp.next != nil{
			// 这里需要注意 上面除了连线 还移动了一下
			temp.next.pre = temp.next
		}
	}
}

func main(){
	// 1.先创建一个头节点
	head := &HeroNode{}
	// 2. 创建一个新的HeroNode
	hero1 := &HeroNode{
		no : 1,
		name : "宋江",
		nickname: "及时雨",
	}
	hero2 := &HeroNode{
		no : 2,
		name : "卢俊义",
		nickname: "玉麒麟",
	}
	hero3 := &HeroNode{
		no : 3,
		name : "林冲",
		nickname: "豹子头",
	}
	// 3. 加入一个节点
	InsertHeroNode(head, hero1)
	InsertHeroNode(head, hero2)
	InsertHeroNode(head, hero3)
	// 4. 显示
	ListHeroNode(head)
	fmt.Println()
	fmt.Println("逆序打印")
	ListHeroNode1(head)
	fmt.Println()
	// 删除
	DelHeroNode(head, 2)
	ListHeroNode(head)
}

2.3 双向链表添加优化

func InsertHeroNode(head *HeroNode, newHeroNode *HeroNode){
	// 1. 找到适当的节点
	// 2. 创建一个辅助节点 【用来帮忙的】
	temp := head
	flag := true
	for {
		// 让插入节点的no 和temp的下一个节点的no 进行比较
		if temp.next == nil{ // 到链表的最后了
			break
		}else if temp.next.no > newHeroNode.no{
			// 说明newHeroNode 就应该插入到temp后面
			break
		}else if temp.next.no == newHeroNode.no{
			// 链表中已经有这个排名 不让插入
			flag = false
			break
		}
		temp = temp.next
	}
	if !flag{
		fmt.Println("对不起，已经存在no=", newHeroNode.no)
		return
	}else{
		// 3. 插入节点
		newHeroNode.next = temp.next
		newHeroNode.pre = temp
		if temp.next != nil{
			temp.next.pre = newHeroNode
		}
		temp.next = newHeroNode
	}
}

第三节 单向环形链表

3.1 单向环形链表介绍

在这里插入图片描述

3.2 单向环形链表实现

  1. 删除一个环形单向链表的思路如下:
    • 先让temp指向head
    • 先让helper指向head遍历后，让helper指向环形链表最后.
    • 让temp和要删除的id进行比较，如果相同，则同helepr完成删除[这里必须考虑如果删除就是头结点]
    • 返回一个新的head, 防止head指向删除节点
      在这里插入图片描述
package main

import (
	"fmt"
)

// 定义猫的结构体
type CatNode struct{
	no int // 猫猫编号
	name string
	next *CatNode
}

// 单向链表和双向链表的头节点都是空的 但是环形链表的头节点要有数据
func InsertCatNode(head *CatNode, newCatNode *CatNode){
	// 判断是不是添加的第一只猫
	if head.next == nil{
		head.no = newCatNode.no
		head.name = newCatNode.name
		head.next = head // 形成环形
		return
	}
	// 定义一个临时变量，帮忙找到环形最后的节点
	temp := head
	for {
		if temp.next == head{
			break
		}
		temp = temp.next
	}
	// 加入到链表中
	temp.next = newCatNode
	newCatNode.next = head
}

// 输出这个环形的链表
func ListCircleLink(head *CatNode){
	fmt.Println("环形链表输出如下")
	temp := head
	if temp.next == nil{
		fmt.Println("空的环形列表")
	}
	for{
		fmt.Printf("猫的信息为=[id=%d name=%s]->\n", temp.no, temp.name)
		if temp.next == nil{
			break
		}
		if temp.next == head{
			break
		}
		temp = temp.next
	}
}

// 删除一个节点
func DeleteCatNode(head *CatNode, id int) *CatNode{
	temp := head
	helper := head
	// 空链表
	if temp.next == nil{
		fmt.Println("这是一个空的环形链表 删不了")
		return head
	}
	// 如果只有一个节点
	if temp.next == head{ 
		if temp.no == id{
			temp.next = nil
			fmt.Printf("删除了no=%d的猫猫", id)
			return head
		}
		fmt.Printf("没有no是%d猫", id)
		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("删除了no=%d的猫猫", id)
			flag = false
			break
		}
		temp = temp.next // 移动 用于比较
		helper = helper.next // 移动 找到helper能帮我们删除它
	}
	// 这里是上面的最后一个
	if flag { //上面没有删除过flag为真
		if temp.no == id{
			helper.next = temp.next
			fmt.Printf("删除了no=%d的猫猫", id)
		}else{
			fmt.Printf("没有no是%d猫", id)
		}
	}
	return head
}

func main(){
	// 这里我们初始化一个环形链表的头节点
	head := &CatNode{}
	// 创建一只猫
	cat1 := &CatNode{
		no : 1,
		name : "tom",
	}
	// cat2 := &CatNode{
	// 	no : 2,
	// 	name : "Som",
	// }
	// cat3 := &CatNode{
	// 	no : 3,
	// 	name : "pom",
	// }
	InsertCatNode(head, cat1)
	// InsertCatNode(head, cat2)
	// InsertCatNode(head, cat3)
	ListCircleLink(head)
	// 这里必须给head重新赋值
	head = DeleteCatNode(head, 1)
	ListCircleLink(head)
}

第四节 约瑟夫问题

4.1 约瑟夫问题介绍

  1. Josephu问题为:设编号为1，2，… n的n个人围坐一圈，约定编号为k(l<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
  2. 方案：用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。
    在这里插入图片描述

4.2 约瑟夫问题解决

package main

import(
	"fmt"
)

// 小孩的结构体
type Boy struct{
	No int // 编号
	Next *Boy // 指向下一个小孩的指针
}

// 编写一个函数,构成单向的环形链表
// num:表示小孩的个数
func AddBoy(num int) *Boy {
	first := &Boy{} //空节点
	curBoy := &Boy{} //空节点 辅助节点
	// 判断
	if num < 1{
		fmt.Println("num的值不对")
		return first
	}
	// 循环的构建这个环形链表
	for i := 1; i <= num; i++{
		boy := &Boy{
			No : i,
		}
		// 分析构成循环链表，需要一个辅助指针[帮忙的]
		//1. 第一个小孩比较特殊
		if i == 1{ //构建第一个小孩
			first = boy
			curBoy = boy
			curBoy.Next = first
		}else{
			curBoy.Next = boy
			curBoy = boy
			curBoy.Next = first //构造环形链表 
		}
	}
	return first
}

// 显示单向的环形链表[遍历]
func ShowBoy(first *Boy){
	// 处理一下 如果环形链表为空
	if first.Next == nil{
		fmt.Println("链表为空")
		return
	}
	
	//创建一个指针 帮助遍历
	curBoy := first
	for {
		fmt.Printf("小孩编号=%d ->", curBoy.No)
		// 退出
		if curBoy.Next == first{
			break
		}
		curBoy = curBoy.Next
	}
}

func GetNumBoy(first *Boy) int {
	curBoy := first
	sum := 0
	if first.Next == nil{
		fmt.Println("链表为空")
		return sum
	}
	for {
		sum++
		if curBoy.Next == first{
			break
		}
		curBoy = curBoy.Next
	}
	return sum
}
//分析思路
//1．编写一个函数，PlayGame(first*Boy,startNo int,countNum int) 头, 开始位置, 计数长度
//2．最后我们使用一个算法，按照要求，在环形链表中留下最后一个人
func PlayGame(first *Boy, startNo int, countNum int){
	//1. 空的链表我们单独处理
	if first.Next == nil{
		fmt.Println("空的链表, 没有小孩")
		return
	}
	fmt.Println(GetNumBoy(first))
	if startNo > GetNumBoy(first){
		fmt.Println("参数输入错误")
		return
	}
	// 2. 创建一个辅助节点, 帮我们删除小孩
	tail := first
	// 3. 让tail执行环形链表的最后一个小孩 tail在删除时需要用到
	for{
		if tail.Next == first{ //说明tail到了最后一个小孩
			break
		}
		tail = tail.Next
	}
	// 4. 让fisrt移动到startNo [后面我们删除小孩 就用first做标准]
	for i := 0; i < startNo -1; i++{
		first = first.Next
		tail = tail.Next
	}
	// 5. 开始数countNum 然后就删除first 指向的小孩
	for{
		// 开始数countNum-1次
		for i := 0; i < countNum - 1; i++{
			first = first.Next
			tail = tail.Next
		}
		fmt.Printf("小孩编号为%d出圈->", first.No)
		// 删除first 指向的小孩
		first = first.Next
		tail.Next = first
		// 如果tail==first,圈中只有一个小孩
		if tail == first{
			break
		}
	}
	fmt.Printf("小孩编号为%d出圈->", first.No)
}



func main(){
	first := AddBoy(5)
	// 显示
	ShowBoy(first)
	PlayGame(first, 2, 3)
}
道教儒佛电磁波
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang数据结构和算法
刘贤松的博客
10-19 454
链表就是链式存储的线性表。根据指针域的不同，链表分为单向链表、双向链表、循环链表等等Insert(t)在树中插入项目 tSearch(t)如果 Item t 存在于树中，则返回 true以中序遍历访问所有节点使用前序遍历访问所有节点使用后序遍历访问所有节点Min()返回存储在树中的具有最小值的项目Max()返回具有最大值存储在树中的项目Remove(t)从树中删除项目 tString()字符串输出。
Golang数据结构-链表(约瑟夫问题)
qq_43498850的博客
04-01 216
文章目录一、Golang数据结构-链表(约瑟夫问题)1.基本介绍2.处理方法二、使用步骤1.建立一个结构体2.创建环形链表并添加数据3.显示链表的所有结点信息4.编写算法，处理约瑟夫问题5.编写一个主函数测试三、运行结果 一、Golang数据结构-链表(约瑟夫问题) 1.基本介绍 Josepho 问题为: 设编号为1，2，…n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依此类推，直到所有人出列为止，..
第一课 golang数据结构和算法-稀疏数组和队列
QnHyn
08-28 316
第一课 golang数据结构和算法-稀疏数组和队列 tags: golang 2019尚硅谷 categories: golang 稀疏数组 队列 文章目录第一课 golang数据结构和算法-稀疏数组和队列第一节 稀疏sparsearray数组1.1 稀疏数组提出1.2 稀疏数组说明1.3 把数组转换为稀疏数组实现1.4 把稀疏数组还原为原数组第二节 队列2.1 队列的介绍2.2 数组模拟队列思路-非环形的队列2.3 数组模拟队列代码实现-非环形的队列2.4 数组模拟队列弊端第三节 环形队列-上面队
Golang的数据结构与算法-----循环双向链表
apple_51747657的博客
12-18 318
/初始化n个节点的循环链表，值为空//先判断n是否大于0if n < 0 {return nil//先创建一个头节点p := r//创建剩下的节点for i := 1;i < n;n++ {p = p.next//然后连成一个循环p.next = rr.prev = preturn r链表和数组可以用来辅助构建各种基本数据结构，我们可以自己定义各种数据结构。
golang数据结构——链表
lp15929801907的博客
03-10 1443
golang链表详解
golang数据结构与算法——稀疏数组、队列和链表
qq_39280718的博客
08-15 342
稀疏数组、队列和链表
算法和数据结构（golang语言实现）
niwoxiangyu的博客
04-15 700
1.1 如何实现链表的逆序。
数据结构与算法 — 链表常见操作（Golang）_golang 链表值 修改
2401_84252820的博客
04-20 837
fmt.Println("第 “, index, " 个节点（尾结点）的数据 ：”, tempNode.Data)fmt.Println("第 “, index, " 个节点的数据 ：”, tempNode.Data)preNode, err := getNode(index - 1) //获取尾结点的前一个结点。preNode, err := getNode(index - 1) //获取尾结点的前一个结点。//fmt.Println(“尾节点的数据 ：”, tempNode.Data)
【golang数据结构和算法】--单链表合并、删除、查找
CrazyJavaPerson的博客
10-21 188
两个有序的链表合并 删除链表倒数第n个结点 求链表的中间结点 // 两个有序的链表合并 // 输入：1->2->4, 1->3->4 // 输出：1->1->2->3->4->4 func (s *SingleLL)MergeTwoList(list1, list2 *Node) (res *Node) { if list1 == n...
golang-workspace:Golang中的示例和其他实验资料的集合
05-10
9. **数据结构与算法**：`datastructures-algorithms`标签意味着项目中包含了各种数据结构（如链表、树、图、堆等）和算法（排序、搜索等）的实现，这对于提升编程技能和优化代码性能非常有帮助。 10. **DoS攻击...
data-structures:数据结构Go实现
04-14
在Go语言中实现数据结构，我们可以利用其强大的语法特性和内存管理能力来创建高效的算法和程序。以下是标题"数据结构:数据结构Go实现"和描述中涉及的数据结构的详细说明： 1. **列表**： 列表是一种线性数据结构，...
C++数据结构第三版
05-20
通过阅读《C++数据结构第三版》，读者不仅可以掌握C++语言中的数据结构实现，还能了解到如何在实际项目中选择合适的数据结构和算法，提升编程技能和解决问题的能力。对于想要在C++领域深耕的开发者来说，这是一本...
algorithms:Go 中的算法（第 4 版）
07-14
6. **数据结构**：数组、链表、栈、队列、树、哈希表等，是实现算法的基础。Go语言提供了丰富的内置类型和结构，方便我们构建复杂的数据结构。 7. **动态规划**：解决最优解问题，如背包问题、最长公共子序列等。Go...
leetcode分类-LeetCode:记录自己在LeetCode中刷过的题目。目前使用C++和Golang两种语言编写，按标签进行了分类
06-30
2. **分析思路**：分析问题的本质，选择合适的数据结构和算法，这是解决问题的关键。 3. **编码实现**：根据思路编写代码，注意代码的可读性和效率。 4. **测试验证**：提交代码后，观察测试用例的结果，确保代码的...
SQL服务器修改服务器排序规则方法
07-17
SQL服务器修改服务器排序规则方法
仓库库存汇总表-Excel模版
07-17
【作品名称】：仓库库存汇总表-Excel模版 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
torchaudio-0.12.1+cpu-cp39-cp39-linux_x86_64.whl
最新发布
07-17
torchaudio软件包，直接下载下来，通过命令窗口输入：pip install torchaudio-xxx.whl安装就行，再也不怕pip安装timeout了
uniapp 安卓资源管理js 非常好用
07-17
uniapp可用的安卓资源管理js文件，可用于安卓平台打开本地文件 配合plus.io读取本地文件
Golang 数据结构和算法 Data Structures & Algorithms In Go
05-01
"《Golang 数据结构和算法 Data Structures & Algorithms In Go》是Hemant Jain撰写的一本关于Go语言的数据结构和算法的参考书籍，以其通俗易懂的特点深受读者欢迎。作者保留了所有版权，并指出未经许可不得复制或...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值