Golang队列实现中遇到的问题

Golang队列实现中遇到的问题 我们需要为队列实现编写代码，我们是这样做的：

Queue

package main
import "fmt"

type queue struct {
    items []int
}

func (q *queue) insertion(item int) {
    q.items = append(q.items, item)
}

func (q *queue) deletion() {
    if len(q.items) == 0 {
        fmt.Println("Out of Bounds")
    }
    items := q.items[1:]
    q.items = items
}
func main() {
    var n int
    _, err := fmt.Scanln(&n)
    if err != nil || n < 0 {
        return
    }
    q := queue{}
    q.insertion(n)
    q.deletion(n)
}

不确定我们哪里做错了。


更多关于Golang队列实现中遇到的问题的实战教程也可以访问 https://www.itying.com/category-94-b0.html

8 回复

问题已解决，谢谢。

更多关于Golang队列实现中遇到的问题的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你正在读取数据切片，然后在末尾插入项目数量。

请重新阅读说明。你应该丢弃多少项，实际上你又丢弃了多少项？

请仔细检查错误，同时检查删除方法中的失败条件。

是的，我告诉过你原因。你调用了 deletion(n)，但并没有一个接受任何参数的 deletion 函数。

你正试图从一个长度为2的切片中删除3个元素，这是无法做到的。在删除之前，请检查你的切片长度是否足够。

你从 stdin 读取一个数字，将其加入队列，然后调用带有一个参数的 deletion()，但只定义了无参数的 deletion()。

另外，请不要只是向我们抛出一些练习和代码，而是告诉我们你当前代码的问题所在。是编译时出现错误？还是输出不符合预期？等等。

你的队列实现有几个问题。主要问题包括：

  1. 删除方法签名错误：deletion() 方法被定义为无参数，但在 main() 中调用时传递了参数 n
  2. 切片操作效率问题：每次删除都创建新切片，导致内存重新分配
  3. 删除逻辑可以优化

这是修正后的代码：

package main

import (
    "fmt"
)

type queue struct {
    items []int
}

// 入队操作
func (q *queue) insertion(item int) {
    q.items = append(q.items, item)
}

// 出队操作 - 修正为无参数
func (q *queue) deletion() (int, bool) {
    if len(q.items) == 0 {
        fmt.Println("Queue is empty")
        return 0, false
    }
    
    item := q.items[0]
    q.items = q.items[1:]
    return item, true
}

// 查看队首元素
func (q *queue) peek() (int, bool) {
    if len(q.items) == 0 {
        return 0, false
    }
    return q.items[0], true
}

// 判断队列是否为空
func (q *queue) isEmpty() bool {
    return len(q.items) == 0
}

func main() {
    var n int
    fmt.Print("Enter a number to insert into queue: ")
    _, err := fmt.Scanln(&n)
    if err != nil || n < 0 {
        fmt.Println("Invalid input")
        return
    }
    
    q := queue{}
    
    // 入队操作
    q.insertion(n)
    fmt.Printf("Inserted %d into queue\n", n)
    
    // 查看队首
    if val, ok := q.peek(); ok {
        fmt.Printf("Front of queue: %d\n", val)
    }
    
    // 出队操作 - 不再传递参数
    if val, ok := q.deletion(); ok {
        fmt.Printf("Deleted %d from queue\n", val)
    }
    
    // 测试空队列删除
    if _, ok := q.deletion(); !ok {
        fmt.Println("Deletion failed - queue is empty")
    }
}

如果你需要更高效的队列实现（避免频繁的内存分配），可以使用指针跟踪队首位置：

type efficientQueue struct {
    items []int
    front int
}

func (q *efficientQueue) insertion(item int) {
    q.items = append(q.items, item)
}

func (q *efficientQueue) deletion() (int, bool) {
    if q.front >= len(q.items) {
        // 定期清理已出队的元素
        if q.front > 0 {
            q.items = q.items[q.front:]
            q.front = 0
        }
        return 0, false
    }
    
    item := q.items[q.front]
    q.front++
    return item, true
}

func (q *efficientQueue) length() int {
    return len(q.items) - q.front
}

主要修改：

  1. 将 deletion() 方法改为无参数，返回出队的元素和成功状态
  2. 添加了辅助方法 peek() 和 isEmpty()
  3. 提供了更高效的队列实现选项，使用 front 指针避免频繁切片操作
  4. 修正了 main() 函数中的方法调用
回到顶部