Go语言的循环链表_链表循环 go-优快云博客

本文链接：https://blog.youkuaiyun.com/2501_91195938/article/details/146408029

Go语言中的循环链表

引言

数据结构是计算机科学的基石，循环链表作为一种重要的链表结构，在许多应用场景中展现出了独特的优势。本文将详细介绍循环链表的定义、特性、基本操作，以及在Go语言中的具体实现，并结合实例分析其在实际应用中的价值。

1. 什么是循环链表？

循环链表是一种特殊的链表结构，它的最后一个节点指向头节点，从而形成一个环。与普通链表相比，循环链表的一个显著特点是没有空的尾指针，这使得在链表中的某一点可以无限循环，而不需要每次都从头开始。

1.1 循环链表的特性

容易遍历：可以从任意节点开始遍历整个链表。
没有空尾节点：循环链表的最后一个节点指向头节点，形成一个闭合的链路。
适合实时任务：由于可以从任意位置开始循环，循环链表特别适合于需要周期性处理的数据结构。

1.2 循环链表的应用

游戏开发：在游戏开发中，循环链表常用于管理游戏对象，比如子弹、敌人等。
音频播放：在音乐播放列表中，可以使用循环链表来实现歌曲的循环播放。
调度算法：在操作系统中，循环链表常用于实现时间片轮转调度。

2. 循环链表的基本操作

循环链表的基本操作包括插入、删除、查找和遍历。下面逐一介绍这些操作。

2.1 节点结构

在Go语言中，我们首先需要定义循环链表的节点结构，示例代码如下：

go type Node struct { value interface{} next *Node }

2.2 创建循环链表

创建一个空的循环链表如下所示：

go type CircularLinkedList struct { head *Node tail *Node }

2.3 插入操作

插入操作可以分为以下几种情况：

插入到链表头部

go func (cll *CircularLinkedList) InsertAtHead(value interface{}) { newNode := &Node{value: value} if cll.head == nil { cll.head = newNode cll.tail = newNode newNode.next = newNode // 指向自己 } else { newNode.next = cll.head cll.tail.next = newNode // 更新尾节点的next cll.head = newNode } }

插入到链表尾部

go func (cll *CircularLinkedList) InsertAtTail(value interface{}) { newNode := &Node{value: value} if cll.tail == nil { cll.head = newNode cll.tail = newNode newNode.next = newNode // 指向自己 } else { cll.tail.next = newNode newNode.next = cll.head // 尾节点的next指向头节点 cll.tail = newNode } }

2.4 删除操作

删除操作同样分为几种情况：

删除指定节点

```go func (cll *CircularLinkedList) Delete(value interface{}) { if cll.head == nil { return } current := cll.head previous := cll.tail

  for {
      if current.value == value {
          // 删除头节点
          if current == cll.head {
              if cll.head == cll.tail {
                  cll.head = nil
                  cll.tail = nil
              } else {
                  cll.head = current.next
                  cll.tail.next = cll.head // 更新尾节点的next
              }
              return
          } else {
              previous.next = current.next
              if current == cll.tail {
                  cll.tail = previous // 更新尾节点
              }
              return
          }
      }
      previous = current
      current = current.next
      if current == cll.head {
          break // 已经遍历完整个链表
      }
  }

} ```

2.5 查找操作

查找操作用于查找链表中是否存在某个节点：

go func (cll *CircularLinkedList) Find(value interface{}) *Node { if cll.head == nil { return nil } current := cll.head for { if current.value == value { return current } current = current.next if current == cll.head { break } } return nil }

2.6 遍历操作

遍历链表以打印每个节点的值：

go func (cll *CircularLinkedList) Traverse() { if cll.head == nil { return } current := cll.head for { fmt.Println(current.value) current = current.next if current == cll.head { break } } }

3. Go语言中循环链表的完整实现

综上所述，下面给出循环链表的完整实现代码：

```go package main

import ( "fmt" )

type Node struct { value interface{} next *Node }

type CircularLinkedList struct { head Node tail Node }

func (cll *CircularLinkedList) InsertAtHead(value interface{}) { newNode := &Node{value: value} if cll.head == nil { cll.head = newNode cll.tail = newNode newNode.next = newNode } else { newNode.next = cll.head cll.tail.next = newNode cll.head = newNode } }

func (cll *CircularLinkedList) InsertAtTail(value interface{}) { newNode := &Node{value: value} if cll.tail == nil { cll.head = newNode cll.tail = newNode newNode.next = newNode } else { cll.tail.next = newNode newNode.next = cll.head cll.tail = newNode } }

func (cll *CircularLinkedList) Delete(value interface{}) { if cll.head == nil { return } current := cll.head previous := cll.tail

for {
    if current.value == value {
        if current == cll.head {
            if cll.head == cll.tail {
                cll.head = nil
                cll.tail = nil
            } else {
                cll.head = current.next
                cll.tail.next = cll.head
            }
            return
        } else {
            previous.next = current.next
            if current == cll.tail {
                cll.tail = previous
            }
            return
        }
    }
    previous = current
    current = current.next
    if current == cll.head {
        break
    }
}

}

func (cll CircularLinkedList) Find(value interface{}) Node { if cll.head == nil { return nil } current := cll.head for { if current.value == value { return current } current = current.next if current == cll.head { break } } return nil }

func (cll *CircularLinkedList) Traverse() { if cll.head == nil { return } current := cll.head for { fmt.Println(current.value) current = current.next if current == cll.head { break } } }

func main() { cll := &CircularLinkedList{} cll.InsertAtHead(1) cll.InsertAtTail(2) cll.InsertAtTail(3) cll.Traverse() // 1 2 3

cll.Delete(2)
cll.Traverse() // 1 3

foundNode := cll.Find(1)
if foundNode != nil {
    fmt.Println("Found:", foundNode.value)
} else {
    fmt.Println("Not found")
}

} ```