Go语言队列实现指南：利用Slices构建高效队列

var queue []int // 声明一个int类型的切片，初始为空
// 或者使用 make 函数预分配容量，但通常不是必须的，因为append会自动处理
// queue := make([]int, 0, initialCapacity)

// Enqueue: 将元素添加到队列尾部
func Enqueue(q []int, element int) []int {
    return append(q, element)
}

// 示例
// queue = Enqueue(queue, 10)
// queue = Enqueue(queue, 20)
// fmt.Println(queue) // 输出: [10 20]

// Dequeue: 从队列头部移除元素
func Dequeue(q []int) (int, []int, bool) {
    if len(q) == 0 {
        return 0, q, false // 队列为空，无法出队
    }
    element := q[0]       // 获取队列头部元素
    q = q[1:]             // 更新切片，移除头部元素
    return element, q, true
}

// 示例
// val, queue, ok := Dequeue(queue)
// if ok {
//     fmt.Printf("出队元素: %d, 剩余队列: %v\n", val, queue) // 输出: 出队元素: 10, 剩余队列: [20]
// }

package main

import "fmt"

// Queue 表示一个基于切片的队列
type Queue struct {
    elements []int
}

// NewQueue 创建一个新的空队列
func NewQueue() *Queue {
    return &Queue{
        elements: make([]int, 0),
    }
}

// Enqueue 将元素添加到队列尾部
func (q *Queue) Enqueue(element int) {
    q.elements = append(q.elements, element)
}

// Dequeue 从队列头部移除元素并返回
// 如果队列为空，返回默认值和false
func (q *Queue) Dequeue() (int, bool) {
    if q.IsEmpty() {
        return 0, false
    }
    element := q.elements[0]
    q.elements = q.elements[1:]
    return element, true
}

// IsEmpty 检查队列是否为空
func (q *Queue) IsEmpty() bool {
    return len(q.elements) == 0
}

// Size 返回队列中元素的数量
func (q *Queue) Size() int {
    return len(q.elements)
}

func main() {
    q := NewQueue()

    fmt.Println("开始入队操作...")
    for i := 1; i <= 12; i++ {
        q.Enqueue(i)
        fmt.Printf("入队 %d, 队列当前: %v\n", i, q.elements)
    }

    fmt.Println("\n开始出队操作...")
    for i := 0; i < 15; i++ { // 尝试出队更多次以观察空队列情况
        val, ok := q.Dequeue()
        if ok {
            fmt.Printf("出队 %d, 队列当前: %v\n", val, q.elements)
        } else {
            fmt.Println("队列已空，无法出队。")
        }
    }
}

package main

import (
    "fmt"
    "time"
)

func main() {
    n := 10000000 // 操作次数
    queue := make([]int, 0, 100) // 预设一个初始容量，减少初期扩容次数

    fmt.Printf("执行 %d 次操作...\n", n)

    // 入队操作性能测试
    start := time.Now()
    for i := 0; i < n; i++ {
        queue = append(queue, i)
    }
    elapsed := time.Since(start)
    fmt.Printf("入队 %d 次耗时: %v\n", n, elapsed)

    // 出队操作性能测试
    start = time.Now()
    for i := 0; i < n; i++ {
        // 避免越界，实际应用中应检查队列是否为空
        if len(queue) > 0 {
            _ = queue[0]
            queue = queue[1:]
        }
    }
    elapsed = time.Since(start)
    fmt.Printf("出队 %d 次耗时: %v\n", n, elapsed)
    fmt.Printf("最终队列长度: %d\n", len(queue))
}

执行 10000000 次操作...
入队 10000000 次耗时: 216.611664ms
出队 10000000 次耗时: 13.441106ms
最终队列长度: 0

// DequeueWithNilHint: 从队列头部移除元素并返回，对指针类型进行nil置空
func (q *Queue) DequeueWithNilHint() (interface{}, bool) { // 假设队列存储interface{}
    if q.IsEmpty() {
        return nil, false
    }
    element := q.elements[0]
    // 如果队列存储的是指针类型，这里可以将 q.elements[0] 置为零值，解除引用
    // 例如：q.elements[0] = nil
    q.elements = q.elements[1:]
    return element, true
}