Question

我一直在学习Go，而我正在用它做一个BFS拼图。我决定的队列实现是：

//define the queue for our BFS algo as frontier.
type frontier struct {
    queue []*graphNode
}

func (F *frontier) buildFrontier() {
    F.queue = make([]*graphNode, 0, 1000)
}

func (F *frontier) pop() (g *graphNode) {
    if F.isEmpty() {
        panic("pop on empty queue!")
    }
    temp := F.queue[0]
    F.queue = F.queue[1:]
    return temp
}

func (F *frontier) push(g *graphNode) {
    F.queue = append(F.queue, g)
}

func (F *frontier) isEmpty() bool {
    return len(F.queue) == 0
}

我有两个问题：

这是一个很好的实施吗？关于go中的队列的文档很稀疏，一般来说有一些关于向量的旧帖子，并且列表似乎有太多的开销（不是这对我的情况很重要，但我试图以最好的方式做到这一点）
为什么对对象的调用（在这种情况下是结构指针F *前沿）必须是指针？这似乎是语法的工作方式，它应该是指针的默认值，而不是显式的（即为什么你不想在这些实例中使用指针？）

修改后的圆形版本：

//define the queue for our BFS algo as frontier.
type frontier struct {
    queue                []*graphNode
    size, head, capacity int
}

func (F *frontier) buildFrontier() {
    F.capacity = 1
    F.queue = make([]*graphNode, F.capacity)
    F.size = 0
    F.head = 0
}

func (F *frontier) pop() (g *graphNode) {
    if F.isEmpty() {
        panic("pop on empty queue!")
    }
    F.size = (F.size - 1)
    temp := F.queue[F.head]
    F.head = (F.head + 1) % F.capacity
    return temp
}

func (F *frontier) push(g *graphNode) {
    if F.isFull() {
        newSlice := make([]*graphNode, F.capacity*2)
        copy(newSlice, F.queue)
        F.queue = newSlice
        F.capacity *= 2
    }
    F.queue[(F.head+F.size)%F.capacity] = g
    F.size = (F.size + 1)
}

func (F *frontier) isEmpty() bool {
    return F.size == 0
}
func (F *frontier) isFull() bool {
    return F.size == F.capacity
}

Answer 1

看起来你的实现会起作用，但最终会有点效率低下。开始时，queue是一个容量为1000的切片。这意味着底层数组可以容纳1000个元素。每次调用pop时，您将队列的开头移动到该阵列的一个元素，从而将容量减少1.最后，当您调用{{{}时，容量将不足以容纳新元素1}}，即使队列中可能没有很多（或任何）元素。这将导致在调用push时分配新数组。无论append和push调用的模式是什么，数组都将被重复重新分配，即使它永远不会保存在1000个元素附近。我建议使用链接列表，可以是pop包中的链接列表，也可以是您自己设计的链接列表。
如果函数将修改接收者的值，或者如果在其他地方使用接收者对象并且必须共享该值，则接收者需要是指针。否则，它不需要是指针。如果值很大，您可能希望将接收器设为指针，以便不必复制它。（接收器的行为与任何其他功能参数相同，并且适用相同的注意事项。）

Go中的结构队列

1 个答案: