Go语言-结构体链表

已于 2022-04-10 23:06:39 修改
阅读量893 收藏
点赞数
文章标签： golang 开发语言 结构体链表
于 2022-04-09 15:22:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59439550/article/details/124027828
版权

目录

前言

1、定义struct的三种方式

2、存储方式

3、链表更新

4、头部添加结构体

5、指定位置插入

6、删除节点

前言

结构体是自定义复杂的数据结构，struck里面可以包含多个字段(属性)，struck类型可以定义方法，和函数有区分，struck属于值类型，且可以做嵌套，Go中没有Class类型，只有struck类型。

1、定义struct的三种方式

格式方式：

1：var struct Student
2：var struct *Student = new (Student)
3：var struct *Student = &Student {}

示例：

package main

import "fmt"

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {

	//实体1
	//第一种方式定义
	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//实体2
	//第二种方式定义
	var stu1 *Student = new(Student)
	stu1.Name = "stu1"
	stu1.Age = 30
	stu1.Score = 54
	head.next = stu1

	//实体3
	//第三种方式定义
	var stu2 *Student = &Student{}
	stu2.Name = "stu2"
	stu2.Age = 32
	stu2.Score = 100
	stu1.next = stu2

	fmt.Println(head)
	fmt.Println(*stu1)
	fmt.Println(*stu2)
}

//运行结果为：
{head 20 80 0xc000112480}
{stu1 30 54 0xc0001124b0}
{stu2 32 100 <nil>}

2、存储方式

示例：值类型存储方式地址空间连续。 

package main

import "fmt"

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
}

func main() {

	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	fmt.Printf("Name:%p\n", &head.Name)
	fmt.Printf("Age:%p\n", &head.Age)
	fmt.Printf("Score:%p\n", &head.Score)
}

//运行结果为：
Name:0xc00005c3c0
Age:0xc00005c3d0
Score:0xc00005c3d8

3、链表更新

链表大小不固定，地址不连续，长度不固定，链表中第一个元素称为头部，最后一个元素指针指向nil。 

链表分类：单链表、双链表、循环单链表、循环双链表。

示例：用遍历的方式遍历结构体。

定义好头部体和前三个结构体，第四个结构体采用for循环。

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//头部结构体
	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//第二个结构体
	var stu1 Student
	stu1.Name = "stu1"
	stu1.Age = 30
	stu1.Score = 90
	//头部结构体---->第一个结构体
	head.next = &stu1

	//第三个结构体
	var stu2 Student
	stu2.Name = "stu2"
	stu2.Age = 40
	stu2.Score = 100
	//第一个结构体---->第二个结构体
	stu1.next = &stu2

	//第四个结构体
	var stu3 Student
	stu3.Name = "stu3"
	stu3.Age = 50
	stu3.Score = 200
	//第二个结构体---->第三个结构体
	stu2.next = &stu3

	//尾部添加节点
	//申明变量
	insterTail(&stu3)

	//定义结构体指针，从头部索引
	//var tmp *Student = &head
	Req(&head)

}

//函数方式遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterTail(tail *Student) {
	for i := 4; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		tail.next = &stu
		tail = &stu
	}

}

//运行结果为：
{head 20 80 0xc0000924b0}
{stu1 30 90 0xc0000924e0}
{stu2 40 100 0xc000092510}
{stu3 50 200 0xc000092540}
{stu4 81 188.10182 0xc000092570}
{stu5 47 87.54284 0xc0000925a0}
{stu6 81 137.36461 0xc0000925d0}
{stu7 25 31.30385 0xc000092600}
{stu8 56 60.182373 0xc000092630}
{stu9 94 162.72798 <nil>}

根据上面的代码进行优化处理：

只定义好头部体，其他结构体都用for循环来表示。

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//头部结构体
	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//尾部添加节点
	//申明变量
	insterTail(&head)

	//定义结构体指针，从头部索引
	Req(&head)

}

//遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterTail(tail *Student) {
	for i := 0; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		tail.next = &stu
		tail = &stu
	}
}

//运行结果为：
{head 20 80 0xc0000c2480}
{stu0 81 188.10182 0xc0000c24b0}
{stu1 47 87.54284 0xc0000c24e0}
{stu2 81 137.36461 0xc0000c2510}
{stu3 25 31.30385 0xc0000c2540}
{stu4 56 60.182373 0xc0000c2570}
{stu5 94 162.72798 0xc0000c25a0}
{stu6 62 76.13144 0xc0000c25d0}
{stu7 28 93.77797 0xc0000c2600}
{stu8 11 58.62037 0xc0000c2630}
{stu9 37 43.71061 <nil>}

4、头部添加结构体

示例：定义好头部结构体，如果想在前面添加结构体怎么操作？

第一种方式：

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//定义头部结构体
	var head *Student = &Student{}

	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//调用头部插入函数
	insterHead(&head)

	//定义结构体指针，从头部索引
	Req(head)

}

//遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterHead(top **Student) {
	for i := 0; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		stu.next = *top
		*top = &stu
	}
}

//运行结果为：
{stu9 37 43.71061 0xc0000c2630}
{stu8 11 58.62037 0xc0000c2600}
{stu7 28 93.77797 0xc0000c25d0}
{stu6 62 76.13144 0xc0000c25a0}
{stu5 94 162.72798 0xc0000c2570}
{stu4 56 60.182373 0xc0000c2540}
{stu3 25 31.30385 0xc0000c2510}
{stu2 81 137.36461 0xc0000c24e0}
{stu1 47 87.54284 0xc0000c24b0}
{stu0 81 188.10182 0xc0000c2480}
{head 20 80 <nil>}

第二种方式：

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//定义头部结构体
	var head Student

	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//调用头部插入函数
	insterHead(&head)

	//定义结构体指针,传入一个新的结构体，进行遍历
	Req(insterHead(&head))

}

//遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterHead(top *Student) *Student {
	for i := 0; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		stu.next = top
		top = &stu
	}
	return top
}

//运行结果为：
{stu9 85 60.304535 0xc0000c2810}
{stu8 37 11.82413 0xc0000c27e0}
{stu7 29 15.890725 0xc0000c27b0}
{stu6 87 121.45068 0xc0000c2780}
{stu5 41 5.6606164 0xc0000c2750}
{stu4 90 139.34384 0xc0000c2720}
{stu3 87 41.316532 0xc0000c26f0}
{stu2 47 59.416515 0xc0000c26c0}
{stu1 28 172.49829 0xc0000c2690}
{stu0 95 72.17428 0xc0000c2480}
{head 20 80 <nil>}

总结：值类型如果想外部数据和函数处理结果同步，两种方法：

①传参指针

②return 返回值

5、指定位置插入

示例：在链表的指定位置，插入一条定义的结构体。

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//头部结构体
	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//尾部添加节点
	//申明变量
	insterTail(&head)

	//定义要插入的新节点
	var newNode *Student = &Student{
		Name:  "newNode",
		Age:   18,
		Score: 120,
	}

	//调用指定位置插入新节点
	addNode(&head, newNode)

	//定义结构体指针，从头部索引
	//var tmp *Student = &head
	Req(&head)

}

//遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterTail(tail *Student) {
	for i := 0; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		tail.next = &stu
		tail = &stu
	}
}

//指定节点插入新节点
func addNode(tmp *Student, newNode *Student) {
	for tmp != nil {
		if tmp.Name == "stu5" {
			//把当前节点断掉，嫁接下一个节点
			newNode.next = tmp.next
			tmp.next = newNode
		}
		//插入节点指向下个节点
		tmp = tmp.next
	}
}

//运行结果为：
{head 20 80 0xc0001124b0}
{stu0 81 188.10182 0xc0001124e0}
{stu1 47 87.54284 0xc000112510}
{stu2 81 137.36461 0xc000112540}
{stu3 25 31.30385 0xc000112570}
{stu4 56 60.182373 0xc0001125a0}
{stu5 94 162.72798 0xc000112690}
{newNode 111 123 0xc0001125d0}
{stu6 62 76.13144 0xc000112600}
{stu7 28 93.77797 0xc000112630}
{stu8 11 58.62037 0xc000112660}
{stu9 37 43.71061 <nil>}

6、删除节点

示例：在一个链表中删除指定的节点。

package main

import (
	"fmt"
	"math/rand"
)

//结构体定义
type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student //存放下一个结构体的地址，用*号直接指向下一个结构体
}

func main() {

	//头部结构体
	var head Student
	head.Name = "head"
	head.Age = 20
	head.Score = 80

	//尾部添加节点
	//申明变量
	insterTail(&head)

	//定义删除函数
	delNode(&head)

	//定义结构体指针，从头部索引
	//var tmp *Student = &head
	Req(&head)

}

//遍历结构体链表
func Req(tmp *Student) {
	//tmp指针指向下一个结构体地址,加*号就是下个结构体
	//遍历输出链表中每个结构体
	for tmp != nil {
		fmt.Println(*tmp)
		//tmp变更为下一个结构体地址
		tmp = tmp.next
	}
}

//添加结构体节点
func insterTail(tail *Student) {
	for i := 0; i < 10; i++ {
		//节点定义
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 200,
		}
		tail.next = &stu
		tail = &stu
	}
}

//删除节点
func delNode(tmp *Student) {
	var prev = tmp
	for tmp != nil {
		if tmp.Name == "stu2" {
			prev.next = tmp.next
			break
		}
		//平移
		//前节点赋值
		prev = tmp
		//后节点赋值
		tmp = tmp.next
	}
}

//运行结果为：
{head 20 80 0xc0001124b0}
{stu0 81 188.10182 0xc0001124e0}
{stu1 47 87.54284 0xc000112540}
{stu3 25 31.30385 0xc000112570}
{stu4 56 60.182373 0xc0001125a0}
{stu5 94 162.72798 0xc0001125d0}
{stu6 62 76.13144 0xc000112600}
{stu7 28 93.77797 0xc000112630}
{stu8 11 58.62037 0xc000112660}
{stu9 37 43.71061 <nil>}
Zlwriii
关注
GO-重点操作：结构体链表
LiuHuan303的博客
04-20 469
目录 1，存储方式 2，链表更新 概念:结构体是自定义复杂数据结构，struc里面可以包含多个字段(属性) , struct类型可以定义方法，和函数有区分，struct属于值类型，且可以做嵌套，Go中没有Class类型， 只有struct类型。 示例:结构体定义 package main ​ import "fmt" ​ //结构体定义 type student struct { name string age int score float32 next.
从零开始学GO ---- 结构体和方法
Ding 的博客
11-12 243
从零开始学GO ---- 结构体和方法 struct Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。 struct结构中的类型可以是任意类型，struct的存储空间是连续的，其字段按照声明时候的顺序存放(注意字段之间有对齐要求） struct有两种类型： struct类型字面量 struct{ FeildName FeildType FeildName FeildType FeildNam
Go语言数据结构-链表
jeremy_ke的博客
10-27 708
linked list，由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表，结构有单向链表、双向链表和环形链表。
Go版数据结构 -【2.2 链表】
最新发布
Swxctx
09-25 1161
链表是一种常见的线性数据结构，与数组不同的是，链表中的元素并不存储在连续的内存空间中，而是通过指针连接在一起。 链表非常适合需要频繁插入、删除操作的场景，因为它不需要像数组那样频繁移动数据。
GO语言数据结构之链表
zlyGOGOGO的博客
08-18 464
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 单向链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个结点的构成：数据+ 后续元素位置指针。 代码实现 package main import "fmt" ..
Go中的链表
z3551906947的博客
05-12 729
一般来说，为了比较好的对单链表进行增删改查的操作，我们会定义一个头节点，头节点的作用主要是来标识链表头，本身这个节点不存放数据示意图no int//判断是不是添加第一只猫head.next = head //构成一个环形return//定义一个临时变量，帮忙，找到最后的结点for {break//加入到链表中// 显示这个环形的链表fmt.Println("环形链表情况如下")fmt.Println("空空如也")returnfor {break// 删除一只猫。
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语言有序链表归并
01-20
在Go语言中，我们可以定义一个`ListNode`结构体来表示链表节点，如下所示： ```go type ListNode struct { Val int Next *ListNode } ``` 在这个结构体中，`Val`字段存储节点的值，`Next`字段是一个指向下一个...
golang 空结构体
weixin_43957354的博客
03-19 1305
今天做力扣141题环形链表，碰到了空结构体这个问题，有点意思，记录一下 原文题解: func hasCycle(head *ListNode) bool { seen := map[*ListNode]struct{}{} for head != nil { if _, ok := seen[head]; ok { return true } seen[head] = struct{}{} head =
2023年go语言面试合集-golangde
02-04
Go语言，又称Golang，是Google在2009年推出的一种静态类型的、编译型的、并发型的、垃圾回收的、具有C语言风格的编程语言。它旨在提高开发效率，提供简单易读的语法，同时支持高效的系统编程。在近年来，Go语言在...
结构体 链表
weixin_44769592的博客
08-19 214
c++结构体数组的初始化 #include <iostream> #include <string.h> using namespace std; struct student{ int num; char name[20]; float score[10]; }; void print(student stu){ cout<<s...
结构体，联合体，字节序，
sinat_39440759的博客
07-29 355
一、数据结构定义： struct A {     int a;     char b[]; }; struct A a1;a2; 二、结构体指针定义(使用前一定要分配空间) struct A *p = (struct A*)malloc(sizeof(struct A)); 结构体长度的原则 1.一定是最长成员的整数倍(double除外 是4的倍数) 2.每个成员的偏移量一定是成员长度的整数倍...
结构体链表
weixin_43424867的博客
06-18 653
链表这种东西一直让人头疼，今天专门看了看，写了个创建链表和删除链表中某个值得程序，需要的可以看看~~~ #include #include<stdlib.h> using namespace std; struct A { int date; A *next; }; void main() { A A1,A2,A3,A4,*head,*p,*q; cout << “创建一个...
掌握Go语言：Go语言链表精解，揭秘高效数据结构，应用场景全揭秘（17）
欢迎来到技术蜜糖罐的IT角落！
03-17 1325
本文详细介绍了链表的常用方法，包括插入节点、删除节点、查找节点、反转链表以及获取链表长度，并提供了相应的示例代码和应用场景。链表作为一种基础的数据结构，在各种场景下都有着重要的应用价值，掌握链表的基本原理和操作方法对于编写高效的Go语言程序至关重要。
结构体中的链表
Brycet的博客
03-03 566
结构体中的链表 package main import "fmt" type Student struct{ Name string Age int Score float32 next *Student } func main(){ var head Student //头节点学生 head.Name = "hua" head.Age = 18 head.Score = 100 var stu1 Student //学生1 stu1.Name = "stu1" st
Go语言实现单向链表
xing的博客
10-29 592
go语言实现单向链表 &amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;使用go语言实现了单向链表的一些基本功能，节点的数据类型为interfa
【Go 数据结构】链表，栈与队列
weixin_55818116的博客
05-05 1428
Go语言实现常见的数据结构，这一系列你一定不要错过，快来学习吧，教你如何使用Go语言实现链表，队列和栈。
Go语言-【结构体】-使用结构体实现链表操作
xyz的专栏
08-30 550
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 使用链表结构可以避免在使用数组时需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。 链表允许插入和移除表上任意位置上的结点，
Go语言任务线程-WRF使用详解
本文主要围绕Go语言中的M（Machine）结构体以及其创建过程进行深入讲解。 M结构体在`runtime.h`文件中被定义，包含了以下几个关键字段： 1. `G* g0`：运行时管理栈，每个M都会有一个默认的G（goroutine）。 2. `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值