Go语言队列实现指南：利用切片与优化考量

queue := []int{} // 初始化一个空整型切片作为队列

// 入队操作：将元素添加到切片末尾
func Enqueue(q []int, item int) []int {
    return append(q, item)
}

// 示例
queue = Enqueue(queue, 1) // queue: [1]
queue = Enqueue(queue, 2) // queue: [1 2]

// 出队操作：从切片头部移除元素并返回
func Dequeue(q []int) (int, []int, bool) {
    if len(q) == 0 {
        return 0, q, false // 队列为空
    }
    item := q[0]    // 获取头部元素
    q = q[1:]       // 移除头部元素，通过重新切片实现
    return item, q, true
}

// 示例
item, queue, ok := Dequeue(queue) // item: 1, queue: [2]

package main

import (
    "fmt"
)

// Queue 定义循环数组队列结构
type Queue struct {
    len  int   // 队列的最大容量
    head int   // 头部指针
    tail int   // 尾部指针
    q    []int // 存储元素的底层切片
}

// New 创建一个新的循环数组队列
func New(n int) *Queue {
    // 队列实际可存储 n-1 个元素，因为需要一个空位来区分满和空
    return &Queue{n, 0, 0, make([]int, n)}
}

// Enqueue 将元素 x 入队
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 // 出队成功
}

package main

import (
    "fmt"
)

type Queue struct {
    len  int
    head, tail int
    q    []int
}

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

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
}

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
}

func main() {
    // 创建一个容量为10的队列，实际可存储9个元素
    q := New(10) 
    fmt.Println("--- Enqueue Operations ---")
    for i := 1; i < 13; i++ { // 尝试入队12个元素
        success := q.Enqueue(i)
        fmt.Printf("Enqueue %d: %v\n", i, success)
    }
    fmt.Println("\n--- Dequeue Operations ---")
    for i := 0; i < 13; i++ { // 尝试出队13次
        val, success := q.Dequeue()
        fmt.Printf("Dequeue: %d, %v\n", val, success)
    }
}

--- Enqueue Operations ---
Enqueue 1: true
Enqueue 2: true
Enqueue 3: true
Enqueue 4: true
Enqueue 5: true
Enqueue 6: true
Enqueue 7: true
Enqueue 8: true
Enqueue 9: true
Enqueue 10: false // 队列已满，无法入队第10个元素
Enqueue 11: false
Enqueue 12: false

--- Dequeue Operations ---
Dequeue: 1, true
Dequeue: 2, true
Dequeue: 3, true
Dequeue: 4, true
Dequeue: 5, true
Dequeue: 6, true
Dequeue: 7, true
Dequeue: 8, true
Dequeue: 9, true
Dequeue: 0, false // 队列已空
Dequeue: 0, false
Dequeue: 0, false
Dequeue: 0, false