跟着动画学习 GO 数据结构之 Go 链表(下)

简介: 我们知道 Go 的数组和切片非常方便对数据进行访问,但是假如我们有一个长度为 5 的数组 [1, 2, 3, 4, 5],想要往其中 3 和 4 之间插入一个元素 6,就往往不是非常容易了。为啥呢?一般解决的方法是首先创建一个长度大于 5 的新数组,因为这个数组的长度首先要能存储旧数组的数组,同时能有多余的位置存储新增加的元素 6。这其中有个操作会很费时,就是复制操作:需要把原来数组中的数据复制到新的内存空间。因此,我们有一个更合适的数据结构叫做链表。

遍历元素

假设 head 指针指向链表的第一个节点,为了遍历整个链表,我们需要进行如下几步操作:

  • 跟随每个指针
  • 随着每次遍历,记录下每个节点的数据(或者 count 计数)
  • 当最后一个指针为空 nil时,停止遍历

图解如下

网络异常,图片无法展示
|

函数如下:

func (linkedList *LinkedList) Traverse() {
  if linkedList.isNull() {
    fmt.Println("The LinkedList is empty")
  }
  currNode := linkedList.headNode
  for currNode != nil {
    fmt.Printf("%v -> ", currNode.data)
    currNode = currNode.next
  }
  fmt.Println()
}

删除元素

  1. 头部删除

图解

网络异常,图片无法展示
|

函数如下:

func (linkedList *LinkedList) DeleteFirst() interface{} {
  if linkedList.isNull() {
    fmt.Println("deleteFirst: List is empty")
  }
  data := linkedList.headNode.data
  linkedList.headNode = linkedList.headNode.next
  linkedList.size--
  return data
}
  1. 中间删除

图解:

网络异常,图片无法展示
|

函数如下:

func (linkedList *LinkedList) Delete(pos int) interface{} {
  if pos < 1 || pos > linkedList.size+1 {
    fmt.Println("delete: Index out of bounds")
  }
  var prev, current *Node
  prev = nil
  current = linkedList.headNode
  p := 0
  if pos == 1 {
    linkedList.headNode = linkedList.headNode.next
  } else {
    for p != pos-1 {
      p = p + 1
      prev = current
      current = current.next
    }
    if current != nil {
      prev.next = current.next
    }
  }
  linkedList.size--
  return current.data
}
  1. 尾部删除

图解:

网络异常,图片无法展示
|

函数如下:

func (linkedList *LinkedList) DeleteLast() interface{} {
  if linkedList.isNull() {
    fmt.Println("deleteLast: List is empty")
  }
  var prev *Node
  current := linkedList.headNode
  for current.next != nil {
    prev = current
    current = current.next
  }
  if prev != nil {
    prev.next = nil
  } else {
    linkedList.headNode = nil
  }
  linkedList.size--
  return current.data
}

总结

好了有了上述函数,我们可以汇总到一起来检验我们的函数是否正确,创建一个 main.go 文件:

package main
import "fmt"
type Node struct {
  data interface{}
  next *Node
}
type LinkedList struct {
  headNode *Node // 头节点
  size     int   // 存储链表的长度
}
func CreateLinkList() *LinkedList {
  // 创建一个空的头节点
  node := new(Node)
  l := new(LinkedList)
  l.headNode = node
  return l
}
// 返回链表的长度
func (linkedList *LinkedList) Length() int {
  return linkedList.Count()
}
func (linkedList *LinkedList) Count() int {
  size := 0
  currNode := linkedList.headNode
  for currNode != nil {
    size++
    currNode = currNode.next
  }
  return size
}
func (linkedList *LinkedList) isNull() bool {
  return linkedList.size == 0
}
func (linkedList *LinkedList) Traverse() {
  if linkedList.isNull() {
    fmt.Println("The LinkedList is empty")
  }
  currNode := linkedList.headNode
  for currNode != nil {
    fmt.Printf("%v -> ", currNode.data)
    currNode = currNode.next
  }
  fmt.Println()
  return
}
func (linkedList *LinkedList) InsertHead(v interface{}) {
  node := &Node{data: v}
  if linkedList.isNull() {
    linkedList.headNode = node
    linkedList.size++
    return
  } else {
    node.next = linkedList.headNode
    linkedList.headNode = node
  }
  linkedList.size++
  return
}
func (linkedList *LinkedList) Append(v interface{}) {
  node := &Node{data: v}
  if linkedList.isNull() {
    linkedList.headNode = node
  } else {
    currNode := linkedList.headNode
    for currNode.next != nil {
      currNode = currNode.next
    }
    currNode.next = node
  }
  linkedList.size++
}
// Insert adds an item at position i
func (linkedList *LinkedList) Insert(pos int, v interface{}) {
  // 先检查待插入的位置是否正确
  if pos < 1 || pos > linkedList.size+1 {
    fmt.Println("Index out of bounds")
  }
  newNode := &Node{data: v}
  var prev, current *Node
  prev = nil
  current = linkedList.headNode
  for pos > 1 {
    prev = current
    current = current.next
    pos = pos - 1
  }
  if prev != nil {
    prev.next = newNode
    newNode.next = current
  } else {
    newNode.next = current
    linkedList.headNode = newNode
  }
  linkedList.size++
}
func (linkedList *LinkedList) DeleteFirst() interface{} {
  if linkedList.isNull() {
    fmt.Println("deleteFirst: List is empty")
  }
  data := linkedList.headNode.data
  linkedList.headNode = linkedList.headNode.next
  linkedList.size--
  return data
}
func (linkedList *LinkedList) DeleteLast() interface{} {
  if linkedList.isNull() {
    fmt.Println("deleteLast: List is empty")
  }
  var prev *Node
  current := linkedList.headNode
  for current.next != nil {
    prev = current
    current = current.next
  }
  if prev != nil {
    prev.next = nil
  } else {
    linkedList.headNode = nil
  }
  linkedList.size--
  return current.data
}
func (linkedList *LinkedList) Delete(pos int) interface{} {
  if pos < 1 || pos > linkedList.size+1 {
    fmt.Println("delete: Index out of bounds")
  }
  var prev, current *Node
  prev = nil
  current = linkedList.headNode
  p := 0
  if pos == 1 {
    linkedList.headNode = linkedList.headNode.next
  } else {
    for p != pos-1 {
      p = p + 1
      prev = current
      current = current.next
    }
    if current != nil {
      prev.next = current.next
    }
  }
  linkedList.size--
  return current.data
}
func main() {
  linkedList := CreateLinkList()
  fmt.Println("初始化创建一个链表,是否为空:", linkedList.isNull())
  nums := []int{1, 2, 3, 4, 5}
  for i := range nums {
    linkedList.Append(nums[i])
  }
  fmt.Println("****************尾部插入[1,2,3,4,5]****************")
  linkedList.Traverse()
  fmt.Print("链表的长度为:")
  fmt.Println(linkedList.Length())
  fmt.Println("****************往头部插入6****************")
  linkedList.InsertHead(6)
  linkedList.Traverse()
  fmt.Println("****************第二个位置插入2022****************")
  linkedList.Insert(2, 2022)
  linkedList.Traverse()
  fmt.Println("****************删除最后一个元素****************")
  last := linkedList.DeleteLast()
  fmt.Println("删除最后一个元素为:", last)
  fmt.Println("****************删除第一个元素****************")
  first := linkedList.DeleteFirst()
  fmt.Println("删除第一个元素为:", first)
  fmt.Println("****************删除位置1的元素****************")
  deleteData := linkedList.Delete(1)
  fmt.Println("删除位置1的元素为:", deleteData)
  fmt.Println("****************最后的链表为:")
  linkedList.Traverse()
}

运行这个方法的结果为:

初始化创建一个链表,是否为空: true
****************尾部插入[1,2,3,4,5]****************
1 -> 2 -> 3 -> 4 -> 5 -> 
链表的长度为:5
****************往头部插入6****************
6 -> 1 -> 2 -> 3 -> 4 -> 5 -> 
****************第二个位置插入2022****************
6 -> 2022 -> 1 -> 2 -> 3 -> 4 -> 5 -> 
****************删除最后一个元素****************
删除最后一个元素为: 5
****************删除第一个元素****************
删除第一个元素为: 6
****************删除位置1的元素****************
删除位置1的元素为: 2022
****************最后的链表为:
1 -> 2 -> 3 -> 4 -> 

至此,我们把基本操作做完成了,为了避免文章过于繁琐,决定把查找的操作放到链表的相关算法问题中再作说明。下一篇文章见!

相关实践学习
基于Hologres+Flink搭建GitHub实时数据大屏
通过使用Flink、Hologres构建实时数仓,并通过Hologres对接BI分析工具(以DataV为例),实现海量数据实时分析.
实时计算 Flink 实战课程
如何使用实时计算 Flink 搞定数据处理难题?实时计算 Flink 极客训练营产品、技术专家齐上阵,从开源 Flink功能介绍到实时计算 Flink 优势详解,现场实操,5天即可上手! 欢迎开通实时计算 Flink 版: https://cn.aliyun.com/product/bigdata/sc Flink Forward Asia 介绍: Flink Forward 是由 Apache 官方授权,Apache Flink Community China 支持的会议,通过参会不仅可以了解到 Flink 社区的最新动态和发展计划,还可以了解到国内外一线大厂围绕 Flink 生态的生产实践经验,是 Flink 开发者和使用者不可错过的盛会。 去年经过品牌升级后的 Flink Forward Asia 吸引了超过2000人线下参与,一举成为国内最大的 Apache 顶级项目会议。结合2020年的特殊情况,Flink Forward Asia 2020 将在12月26日以线上峰会的形式与大家见面。
相关文章
|
6月前
|
安全 Java 编译器
对比Java学习Go——基础理论篇
本章介绍了Java开发者学习Go语言的必要性。Go语言以简单、高效、并发为核心设计哲学,摒弃了传统的类继承和异常机制,采用组合、接口和多返回值错误处理,提升了代码清晰度与开发效率。Go直接编译为静态二进制文件,启动迅速、部署简便,其基于Goroutine和Channel的并发模型相较Java的线程与锁机制更轻量安全。此外,Go Modules简化了依赖管理,与Java的Maven/Gradle形成鲜明对比,提升了构建与部署效率。
481 1
|
6月前
|
消息中间件 缓存 NoSQL
Redis各类数据结构详细介绍及其在Go语言Gin框架下实践应用
这只是利用Go语言和Gin框架与Redis交互最基础部分展示;根据具体业务需求可能需要更复杂查询、事务处理或订阅发布功能实现更多高级特性应用场景。
393 86
|
6月前
|
存储 Java Go
对比Java学习Go——函数、集合和OOP
Go语言的函数支持声明与调用,具备多返回值、命名返回值等特性,结合`func`关键字与类型后置语法,使函数定义简洁直观。函数可作为一等公民传递、赋值或作为参数,支持匿名函数与闭包。Go通过组合与接口实现面向对象编程,结构体定义数据,方法定义行为,接口实现多态,体现了Go语言的简洁与高效设计。
176 4
|
6月前
|
存储 Java 编译器
对比Java学习Go——程序结构与变量
本节对比了Java与Go语言的基础结构,包括“Hello, World!”程序、代码组织方式、入口函数定义、基本数据类型及变量声明方式。Java强调严格的面向对象结构,所有代码需置于类中,入口方法需严格符合`public static void main(String[] args)`格式;而Go语言结构更简洁,使用包和函数组织代码,入口函数为`func main()`。两种语言在变量声明、常量定义、类型系统等方面也存在显著差异,体现了各自的设计哲学。
243 0
|
8月前
|
存储 监控 算法
公司员工泄密防护体系中跳表数据结构及其 Go 语言算法的应用研究
在数字化办公中,企业面临员工泄密风险。本文探讨使用跳表(Skip List)数据结构优化泄密防护系统,提升敏感数据监测效率。跳表以其高效的动态数据处理能力,为企业信息安全管理提供了可靠技术支持。
168 0
|
9月前
|
Go
学习 Go并发模型
本文通过一个简单例子,讲解如何将数组数据转换为其平方值,并将其分解为三个步骤:生产信息(`producer()`)、处理信息(`square()`)和消费信息(`main()`)。进一步介绍了 FAN-OUT 和 FAN-IN 模型的优化,展示了多 goroutine 并发读写通道的实现方式。FAN-OUT 是多个 goroutine 从同一通道读取数据,而 FAN-IN 是单个 goroutine 从多个通道读取数据。最后强调了优化 FAN 模式时需根据具体场景解决瓶颈问题,并推荐使用带缓冲的通道以提高性能。
109 0
学习 Go并发模型
|
12月前
|
算法 数据可视化 开发者
为什么要学习数据结构与算法
今天,我向大家介绍一门非常重要的课程——《数据结构与算法》。这门课不仅是计算机学科的核心,更是每一位开发者从“小白”迈向“高手”的必经之路。
为什么要学习数据结构与算法
|
11月前
|
算法 Go
【LeetCode 热题100】23:合并 K 个升序链表(详细解析)(Go语言版)
本文详细解析了 LeetCode 热题 23——合并 K 个升序链表的两种解法:优先队列(最小堆)和分治合并。题目要求将多个已排序链表合并为一个升序链表。最小堆方法通过维护节点优先级快速选择最小值,;分治合并则采用归并思想两两合并链表。文章提供了 Go 语言实现代码,并对比分析两种方法的适用场景,帮助读者深入理解链表操作与算法设计。
388 10
|
存储 机器学习/深度学习 算法
C 408—《数据结构》算法题基础篇—链表(下)
408考研——《数据结构》算法题基础篇之链表(下)。
453 30