掌握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语言程序至关重要。

相关推荐
Estar.Lee9 分钟前
时间操作[取当前北京时间]免费API接口教程
android·网络·后端·网络协议·tcp/ip
喜欢猪猪11 分钟前
Django：从入门到精通
后端·python·django
一个小坑货11 分钟前
Cargo Rust 的包管理器
开发语言·后端·rust
bluebonnet2715 分钟前
【Rust练习】22.HashMap
开发语言·后端·rust
uhakadotcom38 分钟前
如何实现一个基于CLI终端的AI 聊天机器人？
后端
Iced_Sheep1 小时前
干掉 if else 之策略模式
后端·设计模式
梅见十柒1 小时前
wsl2中kali linux下的docker使用教程（教程总结）
linux·经验分享·docker·云原生
XINGTECODE2 小时前
海盗王集成网关和商城服务端功能golang版
开发语言·后端·golang
程序猿进阶2 小时前
堆外内存泄露排查经历
java·jvm·后端·面试·性能优化·oom·内存泄露
FIN技术铺2 小时前
Spring Boot框架Starter组件整理
java·spring boot·后端
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10量化方法怎么选？如何评估量化后的大模型LLM？