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

链表常用方法详解

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

1. 插入节点

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

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

示例代码：

// 头部插入
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 = newNodereturn}cur := l.Headfor 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.Headfor i := 0; i < index-1 && cur != nil; i++ {cur = cur.Next}if cur == nil {return}newNode.Next = cur.Nextcur.Next = newNode
}

2. 删除节点

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

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

示例代码：

// 根据值删除
func (l *LinkedList) DeleteNodeByValue(val int) {if l.Head == nil {return}if l.Head.Val == val {l.Head = l.Head.Nextreturn}prev := l.Headfor 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.Headfor i := 0; i < index-1 && cur != nil; i++ {cur = cur.Next}if cur == nil || cur.Next == nil {return}cur.Next = cur.Next.Next
}

3. 查找节点

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

示例代码：

// 查找节点
func (l *LinkedList) Search(val int) *ListNode {cur := l.Headfor cur != nil {if cur.Val == val {return cur}cur = cur.Next}return nil
}

4. 反转链表

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

示例代码：

// 反转链表
func (l *LinkedList) Reverse() {var prev *ListNodecur := l.Headfor cur != nil {next := cur.Nextcur.Next = prevprev = curcur = next}l.Head = prev
}

5. 获取链表长度

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

示例代码：

// 获取链表长度
func (l *LinkedList) Length() int {length := 0cur := l.Headfor cur != nil {length++cur = cur.Next}return length
}

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

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

1. LRU缓存

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

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

示例代码：

// 实现LRU缓存结构
type LRUCache struct {capacity intcache    map[int]*Nodehead     *Nodetail     *Node
}type Node struct {key   intvalue intprev  *Nodenext  *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.nextnode.next.prev = node.prev
}// 将节点添加到链表头部
func (l *LRUCache) addToHead(node *Node) {node.prev = l.headnode.next = l.head.nextl.head.next.prev = nodel.head.next = node
}// 向缓存中添加数据
func (l *LRUCache) Put(key int, value int) {if node, ok := l.cache[key]; ok {node.value = valuel.moveToHead(node)} else {newNode := &Node{key:   key,value: value,}l.cache[key] = newNodel.addToHead(newNode)if len(l.cache) > l.capacity {l.removeTail()}}
}// 删除链表尾部节点
func (l *LRUCache) removeTail() {tail := l.tail.prevdelete(l.cache, tail.key)l.removeNode(tail)
}

2. 任务调度

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

示例代码：

// 任务调度队列结构
type TaskQueue struct {head *TaskNodetail *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 = newNodeq.tail = newNode} else {q.tail.next = newNodeq.tail = newNode}
}// 从队列头部取出任务并执行
func (q *TaskQueue) ExecuteTask() {if q.head != nil {task := q.head.taskq.head = q.head.nexttask()}
}

3. 表达式计算

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

示例代码：

// 表达式节点结构
type ExprNode struct {value string // 节点值，可以是操作符或操作数next  *ExprNode
}// 中缀表达式转后缀表达式
func InfixToPostfix(infix []string) []string {var postfix []stringvar stack []*ExprNodefor _, 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 {returnappend(stack, node)
}// 将节点出栈
func pop(stack []*ExprNode) []*ExprNode {return stack[:len(stack)-1]
}