详解Go语言中单链表的使用

 更新时间:2022年8月21日 16:36  点击:282 作者:Hann Yang

链表

一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。使用链表结构可以避免在使用数组时需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。

单链表结构

利用 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语言单链表内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞!

原文出处:https://blog.csdn.net/boysoft2002/article/details/126442832

[!--infotagslink--]

相关文章

  • Go应用中优雅处理Error的技巧总结

    在程序员中,尤其是go新手,经常听到的一个讨论话题是:如何处理错误,这篇文章主要给大家介绍了关于Go应用中优雅处理Error的一些相关技巧,需要的朋友可以参考下...2021-09-08
  • Django def clean()函数对表单中的数据进行验证操作

    这篇文章主要介绍了Django def clean()函数对表单中的数据进行验证操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-07-09
  • golang官方嵌入文件到可执行程序的示例详解

    这篇文章主要介绍了golang官方嵌入文件到可执行程序,本文通过示例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下...2021-02-20
  • go浮点数转字符串保留小数点后N位的完美解决方法

    这篇文章主要介绍了go浮点数转字符串保留小数点后N位解决办法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下...2020-05-11
  • Go语言使用读写OPC详解

    这篇文章主要介绍了Go语言使用读写OPC详解,图文讲解的很清晰,有感兴趣的同学可以学习下...2021-03-05
  • Go中string与[]byte高效互转的方法实例

    string与[]byte经常需要互相转化,普通转化会发生底层数据的复制,下面这篇文章主要给大家介绍了关于Go中string与[]byte高效互转的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下...2021-09-20
  • Go项目的目录结构详解

    这篇文章主要介绍了Go项目的目录结构,对基础目录做了讲解,对项目开发中的其它目录也一并做了介绍,需要的朋友可以参考下...2020-05-01
  • Go 容器遍历的实现示例

    Go 语言提供的基础容器,免不了要查询容器中的数据,那么是如何实现遍历的呢?本文将会介绍几种常用容易的遍历及其使用。感兴趣的可以了解一下...2021-06-13
  • 创建第一个Go语言程序Hello,Go!

    这篇文章主要介绍了创建第一个Go语言程序Hello,Go!本文详细的给出项目创建、代码编写的过程,同时讲解了GOPATH、Go install等内容,需要的朋友可以参考下...2020-05-01
  • 在Django中使用MQTT的方法

    这篇文章主要介绍了在Django中使用MQTT的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧...2021-05-10
  • go语言中的Carbon库时间处理技巧

    这篇文章主要介绍了go语言中的Carbon库时间处理,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下...2021-02-05
  • go嵌套匿名结构体的初始化详解

    这篇文章主要介绍了go嵌套匿名结构体的初始化详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-12-16
  • 解决导入django_filters不成功问题No module named 'django_filter'

    这篇文章主要介绍了解决导入django_filters不成功问题No module named 'django_filter',具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-07-15
  • C语言单链表实现多项式相加

    这篇文章主要为大家详细介绍了C语言单链表实现多项式相加,具有一定的参考价值,感兴趣的小伙伴们可以参考一下...2020-04-25
  • Go语言json编码驼峰转下划线、下划线转驼峰的实现

    这篇文章主要介绍了Go语言json编码驼峰转下划线、下划线转驼峰的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧...2020-06-09
  • 详解如何使用Docker部署Django+MySQL8开发环境

    这篇文章主要介绍了详解如何使用Docker部署Django+MySQL8开发环境,文中通过示例代码以及图文介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧...2020-07-19
  • Django 解决由save方法引发的错误

    这篇文章主要介绍了Django 解决由save方法引发的错误,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-05-21
  • django数据模型中null和blank的区别说明

    这篇文章主要介绍了django数据模型中null和blank的区别说明,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2020-09-03
  • Go 自定义package包设置与导入操作

    这篇文章主要介绍了Go 自定义package包设置与导入操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧...2021-05-06
  • Go语言实现汉诺塔算法

    之前的文章,我们给大家分享了不少汉诺塔算法的实现语言,包括C、c++、java、python等,今天我们就来使用go语言来实现一下,需要的小伙伴来参考下吧。...2020-05-07