详解Go语言中单链表的使用
更新时间：2022年08月21日 09:08:11 作者：Hann Yang
链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。本文将通过实例为大家详解Go语言中单链表的常见用法，感兴趣的可以了解一下
链表
一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。使用链表结构可以避免在使用数组时需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
单链表结构
利用 struct 可以包容多种数据类型，结构体内也可以包含多个成员，这些成员可以是基本类型、自定义类型、数组类型，也可以是指针类型。这里可以使用指针类型成员来存放下一个结点的地址。如以下定义，成员 data 用来存放结点中的数据(整数类型)，next 是指针类型的成员，它指向 ListNode struct 类型数据，也就是下一个结点的数据类型。
type ListNode struct {
data int
next *ListNode
}
创建节点
节点声明和赋值有以下几种格式：
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func main() {
var head *ListNode
head = new(ListNode)
head.data = 1
var node1 = new(ListNode)
node1.data = 2
var node2 = &ListNode{3, nil}
var node3 = &ListNode{data: 4}
fmt.Println(*head)
fmt.Println(*node1)
fmt.Println(*node2)
fmt.Println(*node3)
}
/* 输出：
{1 <nil>}
{2 <nil>}
{3 <nil>}
{4 <nil>}
*/遍历链表
一个for循环即可，结构描述的链表没有空链表的，不论data是何种类型，一旦声明即使不马上赋值也会有类型默认值，比如new(ListNode)即赋值了ListNode{0, nil}。
func showNode(p *ListNode) {
fmt.Print(*p)
for p.next != nil {
p = p.next
fmt.Print("->", *p)
}
fmt.Println()
}
头插法
新结点放在链表的最前面
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func showNode(p *ListNode) {
fmt.Print(*p)
for p.next != nil {
p = p.next
fmt.Print("->", *p)
}
fmt.Println()
}
func main() {
var head = &ListNode{0, nil}
for i := 1; i < 5; i++ {
var node = ListNode{data: i}
node.next = head
head = &node
}
showNode(head)
}
/* 输出：
{4 0xc000084250}->{3 0xc000084240}->{2 0xc000084230}->{1 0xc000084220}->{0 <nil>}
*/尾插法
新结点追加到链表的最后面
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func showNode(p *ListNode) {
fmt.Print(*p)
for p.next != nil {
p = p.next
fmt.Print("->", *p)
}
fmt.Println()
}
func main() {
var head, tail *ListNode
head = &ListNode{0, nil}
tail = head
for i := 1; i < 5; i++ {
var node = ListNode{data: i}
(*tail).next = &node
tail = &node
}
showNode(head)
}
/* 输出：
{0 0xc000084220}->{1 0xc000084230}->{2 0xc000084240}->{3 0xc000084250}->{4 <nil>}
*/遍历方法
方法的定义：参数表放在函数名前
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func (p *ListNode) travel() {
fmt.Print(p.data)
for p.next != nil {
p = p.next
fmt.Print("->", p.data)
}
fmt.Println("<nil>")
}
func main() {
var head = &ListNode{0, nil}
head.travel()
for i := 1; i < 10; i++ {
var node = ListNode{data: i}
node.next = head
head = &node
}
head.travel()
var root *ListNode
root = new(ListNode)
root.travel()
}
/* 输出：
0<nil>
9->8->7->6->5->4->3->2->1->0<nil>
0<nil>
*/链表长度
注意：函数与方法的区别
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func (head *ListNode) size() int {
size := 1
for head = head.next; head != nil; size++ {
head = head.next
}
return size
}
func Len(head *ListNode) int {
size := 1
for head = head.next; head != nil; size++ {
head = head.next
}
return size
}
func main() {
var head = &ListNode{0, nil}
fmt.Println(Len(head))
fmt.Println(head.size())
for i := 1; i < 10; i++ {
var node = ListNode{data: i}
node.next = head
head = &node
}
fmt.Println(Len(head))
fmt.Println(head.size())
}
/* 输出：
1
1
10
10
*/链表转数组
package main
import (
"fmt"
)
type ListNode struct {
data int
next *ListNode
}
func (head *ListNode) size() int {
size := 1
for head = head.next; head != nil; size++ {
head = head.next
}
return size
}
func (head *ListNode) tolist() []int {
var res []int
res = make([]int, 0, head.size())
for head.next != nil {
res = append(res, head.data)
head = head.next
}
res = append(res, head.data)
return res
}
func (head *ListNode) tolist2() []int {
var res []int
res = make([]int, 0, head.size())
res = append(res, head.data)
head = head.next
for head != nil {
res = append(res, head.data)
head = head.next
}
return res
}
func main() {
var head = &ListNode{0, nil}
for i := 1; i < 10; i++ {
var node = ListNode{data: i}
node.next = head
head = &node
}
fmt.Println(head.tolist())
var root, tail *ListNode
root = &ListNode{0, nil}
tail = root
for i := 1; i < 10; i++ {
var node = ListNode{data: i}
(*tail).next = &node
tail = &node
}
fmt.Println(root.tolist2())
}
/* 输出：
[9 8 7 6 5 4 3 2 1 0]
[0 1 2 3 4 5 6 7 8 9]
*/数组转链表
package main
import "fmt"
type ListNode struct {
data int
next *ListNode
}
func (p *ListNode) travel() {
fmt.Print(p.data)
for p.next != nil {
p = p.next
fmt.Print("->", p.data)
}
fmt.Println("<nil>")
}
func toNode(list []int) *ListNode {
var head, tail *ListNode
head = &ListNode{list[0], nil}
tail = head
for i := 1; i < len(list); i++ {
var node = ListNode{data: list[i]}
(*tail).next = &node
tail = &node
}
return head
}
func main() {
var lst = []int{1, 3, 2, 3, 5, 6, 6, 8, 9}
toNode(lst).travel()
}
/* 输出：
1->3->2->3->5->6->6->8->9<nil>
*/到此这篇关于详解Go语言中单链表的使用的文章就介绍到这了,更多相关Go语言单链表内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
golang的值类型和指针类型receiver一直是大家比较混淆的地方，下面这篇文章主要给大家总结介绍了关于golang中值类型/指针类型的变量区别的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下。2017-12-12
在Go语言中,处理JSON数据的编码和解码主要依赖于标准库中的encoding/json包,这个包提供了两个核心的函数：Marshal和Unmarshal,本文给大家介绍了Go语言中处理JSON数据的编码和解码的方法,需要的朋友可以参考下2024-04-04
我们知道 Golang 切片在容量不足的情况下会进行扩容，扩容的原理是怎样的呢，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2021-06-06
go语言中的切片是使用非常频繁的一个数据结构,本文主要介绍了go语言切片去重的3种方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2024-08-08
本文旨在深入探讨Go语言的编译机制和最新的模块管理系统——Go Modules,通过详细的示例和步骤,我们将演示从简单的 “Hello World” 程序到使用第三方库的更复杂项目的开发过程,感兴趣的朋友跟随小编一起看看吧2024-05-05
在日常开发中，可能一不小心就会掉进 Go 语言的某些陷阱里，而本文要介绍的 nil ≠ nil 问题，感兴趣的小伙伴可以跟随小编一起了解一下2022-10-10
最近在看一些rpc框架的使用原理和源码的时候，对中间件的实现非常感兴趣，所以这篇文章就来和大家聊聊Golang的中间件设计模式，希望对大家有所帮助2023-03-03
这篇文章主要介绍了GO语言的IO方法实例小结,Docker的火爆促成了当下新兴的Go语言人气的大幅攀升,需要的朋友可以参考下2015-10-10
这篇文章主要介绍了Gin框架中的PostForm用法及说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-06-06
任务调度（Task Scheduling）是很多软件系统中的重要组成部分，字面上的意思是按照一定要求分配运行一些通常时间较长的脚本或程序。本文将利用Go语言快速实现一个极简任务调度系统，感兴趣的可以了解一下2022-10-10
最新评论