掌握Go语言：Go语言链表精解，揭秘高效数据结构，应用场景全揭秘（17）

技术蜜糖罐2024-03-18 10:18

链表常用方法详解

链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据元素和指向下一个节点的指针。在Go语言中，链表的常用方法包括插入节点、删除节点、查找节点、反转链表以及获取链表长度。下面将逐一详解这些方法，并提供相应的示例。

1. 插入节点

在链表中插入新节点的方法有多种，可以在链表头部、尾部或指定位置插入节点。以下是一些常见的插入节点方法：

  • 头部插入：在链表头部插入新节点，使其成为新的头节点。
  • 尾部插入：在链表尾部插入新节点，使其成为新的尾节点。
  • 指定位置插入：在链表的指定位置插入新节点，需要找到插入位置的前一个节点，并调整指针连接。

示例代码：

go 复制代码 
// 头部插入
func (l *LinkedList) InsertAtHead(val int) {
    newNode := &ListNode{Val: val, Next: l.Head}
    l.Head = newNode
}

// 尾部插入
func (l *LinkedList) InsertAtTail(val int) {
    newNode := &ListNode{Val: val}
    if l.Head == nil {
        l.Head = newNode
        return
    }
    cur := l.Head
    for cur.Next != nil {
        cur = cur.Next
    }
    cur.Next = newNode
}

// 指定位置插入
func (l *LinkedList) InsertAtIndex(index, val int) {
    if index == 0 {
        l.InsertAtHead(val)
        return
    }
    newNode := &ListNode{Val: val}
    cur := l.Head
    for i := 0; i < index-1 && cur != nil; i++ {
        cur = cur.Next
    }
    if cur == nil {
        return
    }
    newNode.Next = cur.Next
    cur.Next = newNode
}

2. 删除节点

从链表中删除节点的方法可以根据节点值或位置进行删除。以下是一些常见的删除节点方法：

  • 根据值删除：删除链表中指定值的节点。
  • 根据位置删除：删除链表中指定位置的节点，需要找到待删除节点的前一个节点，并调整指针连接。

示例代码：

go 复制代码 
// 根据值删除
func (l *LinkedList) DeleteNodeByValue(val int) {
    if l.Head == nil {
        return
    }
    if l.Head.Val == val {
        l.Head = l.Head.Next
        return
    }
    prev := l.Head
    for prev.Next != nil && prev.Next.Val != val {
        prev = prev.Next
    }
    if prev.Next != nil {
        prev.Next = prev.Next.Next
    }
}

// 根据位置删除
func (l *LinkedList) DeleteNodeByIndex(index int) {
    if index == 0 {
        if l.Head != nil {
            l.Head = l.Head.Next
        }
        return
    }
    cur := l.Head
    for i := 0; i < index-1 && cur != nil; i++ {
        cur = cur.Next
    }
    if cur == nil || cur.Next == nil {
        return
    }
    cur.Next = cur.Next.Next
}

3. 查找节点

查找链表中是否存在指定值的节点是链表的常见操作之一。如果找到匹配的节点，则返回该节点的指针；如果未找到，则返回空指针。

示例代码：

go 复制代码 
// 查找节点
func (l *LinkedList) Search(val int) *ListNode {
    cur := l.Head
    for cur != nil {
        if cur.Val == val {
            return cur
        }
        cur = cur.Next
    }
    return nil
}

4. 反转链表

反转链表是将链表中的节点顺序颠倒的操作。通过调整节点之间的指针连接，可以实现链表的反转。

示例代码：

go 复制代码 
// 反转链表
func (l *LinkedList) Reverse() {
    var prev *ListNode
    cur := l.Head
    for cur != nil {
       

 next := cur.Next
        cur.Next = prev
        prev = cur
        cur = next
    }
    l.Head = prev
}

5. 获取链表长度

获取链表长度是衡量链表大小的重要指标之一，可以通过遍历链表并计数节点的方式来获取链表的长度。

示例代码：

go 复制代码 
// 获取链表长度
func (l *LinkedList) Length() int {
    length := 0
    cur := l.Head
    for cur != nil {
        length++
        cur = cur.Next
    }
    return length
}

链表在实际应用中的应用场景

链表是一种基础的数据结构，在实际的软件开发中有着广泛的应用。下面将详细解释链表在LRU缓存、任务调度和表达式计算等场景中的具体应用，并提供相应的示例代码。

1. LRU缓存

LRU（Least Recently Used）缓存是一种常见的缓存淘汰策略，其中最近最少使用的数据会被淘汰出缓存。链表可以很好地支持LRU缓存的实现，通常使用双向链表结合哈希表来实现LRU缓存。

在双向链表中，节点按照访问时间顺序排列，越靠近链表头部的节点表示最近被访问过的数据，而靠近链表尾部的节点表示最久未被访问的数据。当需要从缓存中淘汰数据时，可以直接删除链表尾部的节点。

示例代码：

go 复制代码 
// 实现LRU缓存结构
type LRUCache struct {
    capacity int
    cache    map[int]*Node
    head     *Node
    tail     *Node
}

type Node struct {
    key   int
    value int
    prev  *Node
    next  *Node
}

// 初始化LRU缓存
func Constructor(capacity int) LRUCache {
    return LRUCache{
        capacity: capacity,
        cache:    make(map[int]*Node),
        head:     &Node{},
        tail:     &Node{},
    }
}

// 获取缓存中指定key对应的value
func (l *LRUCache) Get(key int) int {
    if node, ok := l.cache[key]; ok {
        l.moveToHead(node)
        return node.value
    }
    return -1
}

// 将指定节点移动到链表头部
func (l *LRUCache) moveToHead(node *Node) {
    l.removeNode(node)
    l.addToHead(node)
}

// 从链表中删除指定节点
func (l *LRUCache) removeNode(node *Node) {
    node.prev.next = node.next
    node.next.prev = node.prev
}

// 将节点添加到链表头部
func (l *LRUCache) addToHead(node *Node) {
    node.prev = l.head
    node.next = l.head.next
    l.head.next.prev = node
    l.head.next = node
}

// 向缓存中添加数据
func (l *LRUCache) Put(key int, value int) {
    if node, ok := l.cache[key]; ok {
        node.value = value
        l.moveToHead(node)
    } else {
        newNode := &Node{
            key:   key,
            value: value,
        }
        l.cache[key] = newNode
        l.addToHead(newNode)
        if len(l.cache) > l.capacity {
            l.removeTail()
        }
    }
}

// 删除链表尾部节点
func (l *LRUCache) removeTail() {
    tail := l.tail.prev
    delete(l.cache, tail.key)
    l.removeNode(tail)
}

2. 任务调度

任务调度是指根据一定的策略将任务分配给不同的执行单元（如线程、进程等）并进行执行的过程。链表可以作为任务队列的数据结构，实现任务的排队和调度。

示例代码：

go 复制代码 
// 任务调度队列结构
type TaskQueue struct {
    head *TaskNode
    tail *TaskNode
}

// 任务节点结构
type TaskNode struct {
    task func() // 任务函数
    next *TaskNode
}

// 初始化任务调度队列
func NewTaskQueue() *TaskQueue {
    return &TaskQueue{}
}

// 添加任务到队列尾部
func (q *TaskQueue) AddTask(task func()) {
    newNode := &TaskNode{task: task}
    if q.head == nil {
        q.head = newNode
        q.tail = newNode
    } else {
        q.tail.next = newNode
        q.tail = newNode
    }
}

// 从队列头部取出任务并执行
func (q *TaskQueue) ExecuteTask() {
    if q.head != nil {
        task := q.head.task
        q.head = q.head.next
        task()
    }
}

3. 表达式计算

链表可以用于表达式的构建和计算，特别是在中缀表达式转后缀表达式的过程中，链表可以很好地支持操作符和操作数的组织和操作。

示例代码：

go 复制代码 
// 表达式节点结构
type ExprNode struct {
    value string // 节点值，可以是操作符或操作数
    next  *ExprNode
}

// 中缀表达式转后缀表达式
func InfixToPostfix(infix []string) []string {
    var postfix []string
    var stack []*ExprNode

    for _, token := range infix {
        if isOperand(token) {
            postfix = append(postfix, token)
        } else if token == "(" {
            stack = push(stack, &ExprNode{value: token})
        } else if token == ")" {
            for stack[len(stack)-1].value != "(" {
                postfix = append(postfix, stack[len(stack)-1].value)
                stack = pop(stack)
            }
            stack = pop(stack)
        } else {
            for len(stack) > 0 && precedence(stack[len(stack)-1].value) >= precedence(token) {
                postfix = append(postfix, stack[len(stack)-1].value)
                stack = pop(stack)
            }
            stack = push(stack, &ExprNode{value: token})
        }
    }

    for len(stack) > 0 {
        postfix = append(postfix, stack[len(stack)-1].value)
        stack = pop(stack)
    }

    return postfix
}

// 判断是否为操作数
func isOperand(token string) bool {
    return token >= "0" && token <= "9"
}

// 获取操作符的优先级
func precedence(operator string) int {
    if operator == "+" || operator == "-" {
        return 1
    } else if operator == "*" || operator == "/" {
        return 2
    }
    return 0
}

// 将节点入栈
func push(stack []*ExprNode, node *ExprNode) []*ExprNode {
    return

 append(stack, node)
}

// 将节点出栈
func pop(stack []*ExprNode) []*ExprNode {
    return stack[:len(stack)-1]
}

注意事项

在使用链表时，需要注意以下事项：

  • 内存泄漏：需要确保及时释放不再使用的节点内存，避免内存泄漏问题。
  • 指针操作：链表的操作涉及指针的操作，需要确保指针的正确性，防止出现空指针异常。
  • 性能问题：链表的插入、删除操作时间复杂度为O(1)，但查找操作的时间复杂度为O(n)，在某些场景下可能存在性能问题。

总结

本文详细介绍了链表的常用方法，包括插入节点、删除节点、查找节点、反转链表以及获取链表长度，并提供了相应的示例代码和应用场景。链表作为一种基础的数据结构，在各种场景下都有着重要的应用价值，掌握链表的基本原理和操作方法对于编写高效的Go语言程序至关重要。

相关推荐
zjw_rp10 分钟前
Spring-AOP
java·后端·spring·spring-aop
TodoCoder31 分钟前
【编程思想】CopyOnWrite是如何解决高并发场景中的读写瓶颈？
java·后端·面试
机器之心2 小时前
图学习新突破：一个统一框架连接空域和频域
人工智能·后端
.生产的驴3 小时前
SpringBoot 对接第三方登录 手机号登录 手机号验证 微信小程序登录 结合Redis SaToken
java·spring boot·redis·后端·缓存·微信小程序·maven
顽疲3 小时前
springboot vue 会员收银系统 含源码 开发流程
vue.js·spring boot·后端
机器之心3 小时前
AAAI 2025｜时间序列演进也是种扩散过程？基于移动自回归的时序扩散预测模型
人工智能·后端
hanglove_lucky4 小时前
本地摄像头视频流在html中打开
前端·后端·html
探索云原生5 小时前
在 K8S 中创建 Pod 是如何使用到 GPU 的： nvidia device plugin 源码分析
ai·云原生·kubernetes·go·gpu
启明真纳5 小时前
elasticache备份
运维·elasticsearch·云原生·kubernetes
皓木.5 小时前
(自用)配置文件优先级、SpringBoot原理、Maven私服
java·spring boot·后端
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04机器人编程怎么入门？05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07SQL 主从数据库实时备份08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10VSCode插件 —— Cody AI （免费AI助手！）