Go语言数据结构-链表

已于 2022-11-04 11:59:47 修改
阅读量708 收藏 2
点赞数
分类专栏： Golang 数据结构和算法 文章标签： 数据结构 链表 golang
于 2022-10-27 00:29:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeremy_ke/article/details/127543851
版权

定义

linked list，由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表，结构有单向链表、双向链表和环形链表。

特点

查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
增删元素快：添加或者删除某个元素，只要更换上一个节点和下一个节点就可以了

应用场景

  1. 结合哈希表：LRU 缓存、链地址法解决哈希冲突。
  2. 循环链表：约瑟夫问题

单向链表

在这里插入图片描述

基本结构和操作

//
// LinkNode
// @Description: 链表节点
//
type LinkNode struct {
	value string
	next  *LinkNode
}
添加节点
//
// AddNode
// @Description: 添加节点
// @Author: maxwell.ke
// @time 2022-10-26 13:59:34
// @receiver ln
// @param n
// @return error
//
func (ln *LinkNode) AddNode(addNode *LinkNode) error {
	tail := ln
	for {
		if tail.next == nil {
			//找到了最后一个结点
			break
		}
		//如果没有找到，把当前结点的next指向临时结点
		tail = tail.next
	}
	tail.next = addNode
	return nil
}
删除节点
//
// DelNode
// @Description: 移除节点
// @Author: maxwell.ke
// @time 2022-10-26 14:07:13
// @receiver ln
// @param delNode
// @return error
//
func (ln *LinkNode) DelNode(delNode *LinkNode) error {
	tail := ln
	for {
		//找到比需要删除的节点的前一个节点
		if delNode == tail { //删除的是头节点,不可删除
			return fmt.Errorf("头节点不可删除")
		}
		if tail.next == nil {
			return fmt.Errorf("没有找到需要删除的节点")
		}
		if tail.next == delNode {
			break
		}
		//如果没有找到，把当前结点的next指向临时结点
		tail = tail.next
	}
	//开始删除
	tail.next = delNode.next
	return nil
}
遍历链表
//
// ShowLink
// @Description: 遍历链表
// @Author: maxwell.ke
// @time 2022-10-26 14:30:51
// @receiver ln
//
func (ln *LinkNode) ShowLink() {
	tail := ln
	for {
		if tail == nil {
			break
		}
		fmt.Printf("[%s]->", tail.value)
		tail = tail.next
	}
	fmt.Println()
}

双向链表

在这里插入图片描述

基本结构和操作

type HeroNode struct {
	val string
	pre		 *HeroNode
	next     *HeroNode
}
添加节点
//
// AddNode
// @Description: 添加节点
// @Author: maxwell.ke
// @time 2022-10-26 14:47:52
// @receiver ln
// @param node
//
func (ln *LinkNode) AddNode(node *LinkNode) {
	tail := ln
	for {
		if tail.next == nil {
			//找到了最后一个结点
			break
		}
		//如果没有找到，把当前结点的next指向临时结点
		tail = tail.next
	}
	tail.next = node
	node.pre = tail
}
删除节点
//
// DelNode
// @Description: 删除节点
// @Author: maxwell.ke
// @time 2022-10-26 14:51:27
// @receiver ln
// @param delNode
// @return error
//
func (ln *LinkNode) DelNode(delNode *LinkNode) error {
	tail := ln
	for {
		//找到比需要删除的节点的前一个节点
		if delNode == ln {
			return fmt.Errorf("头结点不可删除")
		}
		if tail.next == nil {
			return fmt.Errorf("没有找到需要删除的节点")
		}
		if tail.next == delNode {
			break
		}
		//如果没有找到，把当前结点的next指向临时结点
		tail = tail.next
	}
	//开始删除
	tail.next = delNode.next
	delNode.next.pre = tail
	return nil
}
遍历链表
//
// ShowLink
// @Description: 遍历链表
// @Author: maxwell.ke
// @time 2022-10-26 14:54:17
// @receiver ln
//
func (ln *LinkNode) ShowLink() {
	tail := ln
	if tail.next == nil {
		fmt.Println("空链表")
		return
	}
	for {
		fmt.Printf("[%s]->", tail.next.value)
		tail = tail.next
		if tail.next == nil {
			break
		}
	}
	fmt.Println()
}

环形链表

环形单向链表

在这里插入图片描述

//
// LinkNode
// @Description: 链表节点
//
type LinkNode struct {
	value string
	next  *LinkNode
}
添加节点
func (ln *LinkNode) AddNode(newNode *LinkNode) {
	//头节点,直接加
	if ln.next == nil {
		ln.value = newNode.value
		ln.next = ln
		return
	}
	tail := ln
	for {
		if tail.next == ln {
			break
		}
		tail = tail.next
	}
	//加入链表
	tail.next = newNode
	newNode.next = ln

}
删除节点
//
// DelNode
// @Description: 删除节点
// @Author: maxwell.ke
// @time 2022-10-26 15:51:54
// @receiver ln
// @param delNode
// @return newLink
// @return err
//
func (ln *LinkNode) DelNode(delNode *LinkNode) (newLink *LinkNode, err error) {
	//空链表
	if ln.next == nil {
		return nil, fmt.Errorf("链表为空")
	}

	//1个元素的链表
	if ln.next == ln {
		if ln == delNode {
			return nil, nil
		} else {
			return nil, fmt.Errorf("未找到要删除的节点")
		}
	}

	//多个元素的链表
	tailNode := ln //头节点
	rearNode := ln //尾节点
	//找到尾结点
	for {
		if rearNode.next == ln {
			break
		}
		rearNode = rearNode.next
	}

	for {
		//头节点就是需要删除的节点
		if tailNode == delNode {
			newLink = tailNode.next
			rearNode.next = newLink
			break
		}
		//中间节点是需要删除的节点
		if tailNode.next == delNode {
			tailNode.next = delNode.next
			break
		}
		//尾节点是需要删除的节点
		if tailNode.next == ln {
			if tailNode == delNode {
				//找到倒数第二个节点
				descSecondNode := ln
				for {
					if descSecondNode.next == tailNode {
						break
					}
					descSecondNode = descSecondNode.next
				}
				descSecondNode.next = ln
			} else {
				return nil, fmt.Errorf("未找到要删除的节点")
			}
			break
		}
		tailNode = tailNode.next
	}
	return
}
遍历链表
//
// showLink
// @Description: 遍历链表
// @Author: maxwell.ke
// @time 2022-10-26 15:54:18
// @receiver ln
//
func (ln *LinkNode) showLink() {
	tail := ln
	if tail.next == nil {
		fmt.Println("链表为空")
		return
	}
	for {
		fmt.Printf("%s-->", tail.value)
		if tail.next == ln {
			break
		}
		tail = tail.next
	}
	fmt.Println()
}
案例:约瑟夫问题

设编号为1，2…n个人围成一圈，约定编号为K(1 <= k <= n)的人从1开始报数，数到m的那个人
出列，它的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此产生
一个出列编号的序列。

package main

import "fmt"

type joshefu struct {
	no   int
	next *joshefu
}

/**
 * @Description: 创建一个链表
 * @Param:num:链表的长度
 * @Return:返回环形链表的头结点
 */
func addLink(num int) *joshefu {
	if num <= 0 {
		return nil
	}
	head := &joshefu{}
	p := head
	for i := 1; i <= num; i++ {
		p.no = i
		if i == num {
			p.next = head
		} else {
			p.next = &joshefu{}
		}
		p = p.next
	}
	return head
}

func showLink(head *joshefu) {
	p := head
	for {
		if p.next == nil {
			fmt.Println("链表为空")
			break
		}
		fmt.Printf("%d -->", p.no)
		if p.next == head {
			break
		}
		p = p.next
	}
	fmt.Println()
}

func delLink(head *joshefu, start int, step int) {
	if head.next == nil {
		fmt.Println("链表为空")
		return
	}
	//寻找尾节点
	rearNode := head
	for {
		if rearNode.next == head {
			break
		}
		rearNode = rearNode.next
	}

	//让head移动到start节点（start-1）
	for i := 1; i <= start-1; i++ {
		head = head.next
		rearNode = rearNode.next
	}

	//创建一个数组
	var delArr []int

	fmt.Println(head.no)
	//找到删除节点并删除
	for {
		for j := 1; j <= step-1; j++ {
			head = head.next
			rearNode = rearNode.next
		}
		delArr = append(delArr, head.no)
		head = head.next
		rearNode.next = head
		if head == rearNode {
			delArr = append(delArr, head.no)
			break
		}

	}
	//展示出列顺序
	fmt.Println(delArr)
}

func main() {
	linkHead := addLink(10)
	showLink(linkHead)
	delLink(linkHead, 3, 4)
}
jeremyke07
关注
专栏目录
Go：DoublyLinkedList双链表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-20 155
Go：DoublyLinkedList双链表(附完整源码)
golang数据结构-链表
weixin_53909942的博客
08-12 485
此文章用于数据结构学习记录
Go中的链表
z3551906947的博客
05-12 729
一般来说，为了比较好的对单链表进行增删改查的操作，我们会定义一个头节点，头节点的作用主要是来标识链表头，本身这个节点不存放数据示意图no int//判断是不是添加第一只猫head.next = head //构成一个环形return//定义一个临时变量，帮忙，找到最后的结点for {break//加入到链表中// 显示这个环形的链表fmt.Println("环形链表情况如下")fmt.Println("空空如也")returnfor {break// 删除一只猫。
Go版数据结构 -【2.2 链表】
Swxctx
09-25 1161
链表是一种常见的线性数据结构，与数组不同的是，链表中的元素并不存储在连续的内存空间中，而是通过指针连接在一起。 链表非常适合需要频繁插入、删除操作的场景，因为它不需要像数组那样频繁移动数据。
go 实现双向链表
实践求真知
05-27 317
一说明 使用带head头的双向链表实现——水浒英雄排行榜管理。 单向链表的缺点分析。 1单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 2单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，单链表删除时，总要找到temp的下一个节点来删除。 二图解 三代码 package main import ( "fmt" ) // HeroNode type HeroNode struct { no int n...
go语言实现链表
JIYILANZHOU的专栏
05-18 555
声明结构体//声明全局变量，保存头结点 var head *Node var curr *Node //声明节点类型 type Node struct { //数据域 Data string //地址域 NextNode *Node }//创建头结点 func CreateHeadNode(data string) *Node { var node *Node = new(Node) ...
go语言基础4——链表
一蓑烟雨任平生
10-27 1004
我们今天主要讨论了。
Golang数据结构-链表(约瑟夫问题)
qq_43498850的博客
04-01 234
文章目录一、Golang数据结构-链表(约瑟夫问题)1.基本介绍2.处理方法二、使用步骤1.建立一个结构体2.创建环形链表并添加数据3.显示链表的所有结点信息4.编写算法，处理约瑟夫问题5.编写一个主函数测试三、运行结果 一、Golang数据结构-链表(约瑟夫问题) 1.基本介绍 Josepho 问题为: 设编号为1，2，…n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依此类推，直到所有人出列为止，..
基于Java、Go、Python的多语言实现链表数据结构算法源码
最新发布
10-01
该项目是一个多语言实现的链表数据结构算法源码库，涵盖Java、Go和Python三种编程语言。该库包含61个文件，包括21个Java类文件、8个Go源文件、8个Python源文件以及相关配置和管理文件。该项目旨在提供一个跨语言对比...
Go数据结构-集合、列表、堆栈、地图、树、队列等等
02-22
Go语言，作为一种高效、简洁的编程语言，提供了丰富的内置数据类型，但为了实现更复杂的数据处理，我们经常需要自定义或利用库来构建特定的数据结构。本篇文章将深入探讨Go语言中的集合、列表、堆栈、地图、树和队列...
数据结构---如何判定链表是否有环_如何判断链表是否有环
2201_75604580的博客
04-07 887
可以对第一 个链表的节点地址进行hash排序，建立hash表，然后针对第二个链表的每个节点的地址查询hash表，如果它在hash表中出现，则说明两个链表有共 同的结点。对于相交的第一个结点，则可求出两个链表的长度，然后用长的减去短的得到一个差值 K，然后让长的链表先遍历K个结点，然后两个链表再开始比较。例如链表A->B->C->D->B->C->D，两个指针最初都指向节点A，进入第一轮循环，指针1移动到了节点B，指针2移动到了C。第二轮循环，指针1移动到了节点C，指针2移动到了节点B。
Go数据结构------链表
zhangzhongyanting的博客
05-06 749
映射起来的内置语法结构，数据和数据之间是挨着，存放在一个连续的内存区域，每一个固定大小（8字节）的内存片段都有一个虚拟的地址编号。另一个是我们定义的数据结构，通过一个数据节点，可以定位到另一个数据节点，不要求连续的内存空间。有些书籍，把链表做了很细的划分，比如单链表，双链表，循环单链表，循环双链表，其实没有必要强行分类，链表就是从一个数据指向另外一个数据，一种将数据和数据关联起来的结构而已。问题是，有时候需要做删除，移动等各种操作，而数组的大小是固定的，需要大量空间移动，所以某些情况下，数组的效率很低。
07-【go】go语言中的链表
qq_42303254的博客
05-11 405
https://www.cnblogs.com/wdliu/p/9209419.html—在这篇文章中搜索“链表” 学习过程： package main import ( "fmt" ) type Node struct { data int next *Node } func Shownode(p *Node) { // 遍历 for p != nil { fmt.Println(*p) //fmt.Println(p) p = p.next // 移动指针 } }.
Go语言-结构体链表
Zlwriii的博客
04-09 893
目录 前言 1、定义struct的三种方式 2、存储方式 3、链表更新 4、头部添加结构体 5、指定位置插入 6、删除节点 前言 结构体是自定义复杂的数据结构，struck里面可以包含多个字段(属性)，struck类型可以定义方法，和函数有区分，struck属于值类型，且可以做嵌套，Go中没有Class类型，只有struck类型。 1、定义struct的三种方式 格式方式： 1：var struct Student 2：var struct *Student = new (St
[Go语言]实现链表
我的编程世界
10-13 568
链表是一个结点指向下一个结点的存储结构，每一个结点有两个元素，一个是存放数据本身，另一个数据指向下一个结点，由这些结点组成一个链表 思路： 需要先定义一个结点类包含两个元素，一个数据，一个指向下一结点 定义一个链表，包含一个头结点的元素 根据链表中头结点中包含下一个结点循环找到最后的结点，在最后增加新的结点 代码实现 package main import "fmt" type Node struct { data int next *Node } type NodeList struct {
【Go 数据结构】链表，栈与队列
weixin_55818116的博客
05-05 1428
Go语言实现常见的数据结构，这一系列你一定不要错过，快来学习吧，教你如何使用Go语言实现链表，队列和栈。
Go 实现链表
qq_43756091的博客
01-08 323
package list import "fmt" type DLinkedList struct { head, tail *DLinkedNode size int } func NewDLinkedList() *DLinkedList { list := &DLinkedList{ head: new(DLinkedNode), tail: new(DLinkedNode), } list.head.next = list.tail list.tail.
GO语言数据结构之链表
zlyGOGOGO的博客
08-18 464
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 单向链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个结点的构成：数据+ 后续元素位置指针。 代码实现 package main import "fmt" ..
【数据结构】链表 - Go 语言实现
weixin_44211968的博客
02-24 1963
本文主要展示了循环链表的 Go 语言实现，其他链表更简单。 理解了循环链表，其他简单链表便不在话下。
Golang实现链表数据结构
"这篇资源是关于Golang语言实现链表的数据结构。主要涵盖了链表的基本操作，包括创建链表、获取链表长度、添加元素、查找元素以及获取指定位置的元素。" 在Golang中，链表是一种常用的数据结构，它不依赖于内存的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值