Go语言中队列的实现：利用切片构建高效且惯用的队列

type Queue struct {
    len        int // 队列容量
    head, tail int // 队头、队尾指针
    q          []int // 存储元素的底层数组
}

func New(n int) *Queue {
    return &Queue{n, 0, 0, make([]int, n)}
}

// Enqueue 入队操作
func (p *Queue) Enqueue(x int) bool {
    // 检查是否已满
    ntail := (p.tail + 1) % p.len
    if ntail == p.head {
        return false // 队列已满
    }
    p.q[p.tail] = x
    p.tail = ntail
    return true
}

// Dequeue 出队操作
func (p *Queue) Dequeue() (int, bool) {
    // 检查是否为空
    if p.head == p.tail {
        return 0, false // 队列为空
    }
    x := p.q[p.head]
    p.head = (p.head + 1) % p.len
    return x, true
}

// 假设 queue 是一个 []int 类型的切片
queue := []int{}

// 入队操作：向队列末尾添加元素
queue = append(queue, elementToAdd)

package main

import "fmt"

func main() {
    queue := []int{}
    fmt.Println("初始队列:", queue)

    // 入队操作
    queue = append(queue, 10)
    fmt.Println("入队 10 后:", queue)

    queue = append(queue, 20)
    fmt.Println("入队 20 后:", queue)
}

初始队列: []
入队 10 后: [10]
入队 20 后: [10 20]

// 假设 queue 是一个 []int 类型的切片，且不为空
el := queue[0] // 获取队头元素
queue = queue[1:] // 移除队头元素

package main

import "fmt"

func main() {
    queue := []int{10, 20, 30}
    fmt.Println("初始队列:", queue)

    // 出队操作
    if len(queue) > 0 {
        el := queue[0]
        queue = queue[1:]
        fmt.Printf("出队元素: %d, 剩余队列: %v\n", el, queue)
    }

    if len(queue) > 0 {
        el := queue[0]
        queue = queue[1:]
        fmt.Printf("出队元素: %d, 剩余队列: %v\n", el, queue)
    }

    if len(queue) > 0 {
        el := queue[0]
        queue = queue[1:]
        fmt.Printf("出队元素: %d, 剩余队列: %v\n", el, queue)
    } else {
        fmt.Println("队列已空，无法出队。")
    }
}

初始队列: [10 20 30]
出队元素: 10, 剩余队列: [20 30]
出队元素: 20, 剩余队列: [30]
出队元素: 30, 剩余队列: []

package main

import (
    "fmt"
    "sync" // 引入 sync 包用于互斥锁，确保并发