递归地附加到切片切片

从现在开始，努力学习吧！本文《递归地附加到切片切片》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我正在尝试在 go 中实现一个简单的函数，该函数返回一组数字的所有排列。我让它打印所有排列，但我无法让它将它们附加到 2d 切片中。 这是排列的代码：

package main

import "fmt"

// generating permutation using heap algorithm
func heappermutation(p *[][]int, a []int, size, n, count int) int {
    count++
    // if size becomes 1 then prints the obtained
    // permutation
    if size == 1 {
        fmt.println(a)
        *p = append(*p, a)
        return count
    }
    i := 0
    for i < size {
        count = heappermutation(p, a, size-1, n, count)

        // if size is odd, swap first and last
        // element
        // else if size is even, swap ith and last element
        if size%2 != 0 {
            a[0], a[size-1] = a[size-1], a[0]
        } else {
            a[i], a[size-1] = a[size-1], a[i]
        }
        i++
    }
    return count
}

这是主要功能：

func main() {
    listnumbers := []int{1, 2, 3}
    n := len(listnumbers)
    permutations := make([][]int, 0)
    p := &permutations
    heappermutation(p, listnumbers, n, n, 0)
    fmt.print(permutations)
}

当我运行此代码时，我得到以下输出：

[1 2 3]
[2 1 3]
[3 1 2]
[1 3 2]
[2 3 1]
[3 2 1]
[[1 2 3] [1 2 3] [1 2 3] [1 2 3] [1 2 3] [1 2 3]]

所以你可以看到该函数能够找到排列，但是当我尝试附加它时会发生一些奇怪的事情。如果我在每个附加之前添加 fmt.println(*p) 我会得到以下结果：

[1 2 3]
[[1 2 3]]
[2 1 3]
[[2 1 3] [2 1 3]]
[3 1 2]
[[3 1 2] [3 1 2] [3 1 2]]
[1 3 2]
[[1 3 2] [1 3 2] [1 3 2] [1 3 2]]
[2 3 1]
[[2 3 1] [2 3 1] [2 3 1] [2 3 1] [2 3 1]]
[3 2 1]
[[3 2 1] [3 2 1] [3 2 1] [3 2 1] [3 2 1] [3 2 1]]
[[1 2 3] [1 2 3] [1 2 3] [1 2 3] [1 2 3] [1 2 3]]

所以看起来每次我使用追加时，它都会添加新切片并覆盖所有其他切片。为什么会发生这样的事？顺便说一下，如果我只使用全局变量而不是指针，效果是一样的。

谢谢

解决方案

您不是将不同的 []int 切片附加到更大的 [][]int 切片中，而是一遍又一遍地附加相同的切片 (a)。并且您多次修改 a 。最后，您已将 a 修改回原来的状态，这就是为什么您的最终输出看起来像原始输入 listnumbers 重复了六次。

这是查看问题的更直接的方法：

package main

import "fmt"

func main() {
  a := []int{1}
  p := [][]int{a, a, a}
  fmt.println(p) // [[1] [1] [1]]
  a[0] = 2
  fmt.println(p) // [[2] [2] [2]]
}

要获得所需的结果，您需要复制 a，当您随后修改 a 时，这些副本不会受到影响。例如：

tmp := make([]int, len(a))
copy(tmp, a)
*p = append(*p, tmp)

了解有关 copy here 的更多信息。

好的，在 @amit kumar gupta 的帮助下，我成功了！ 这是新代码： 包主要

import "fmt"

    // Generating permutation using Heap Algorithm
    func heapPermutation(p *[][]int, a []int, size, n, count int) int {
        count++
        // if size becomes 1 then prints the obtained
        // permutation
        if size == 1 {
            fmt.Println(a)
            tmp := make([]int, len(a)) 
            /*
            'a' is like a pointer to an object,
            every time you modify 'a' it will change all the elemets of 'a'
            in the permutations list.
            like so
            :
            a := []int{1}
            p := [][]int{a, a, a}
            fmt.Println(p) // [[1] [1] [1]]
            a[0] = 2
            fmt.Println(p) // [[2] [2] [2]]
            */
            copy(tmp, a)
            *p = append(*p, tmp)
            fmt.Println(*p)
            return count
        }
        i := 0
        for i < size {
            count = heapPermutation(p, a, size-1, n, count)

            // if size is odd, swap first and last
            // element
            // else If size is even, swap ith and last element
            if size%2 != 0 {
                a[0], a[size-1] = a[size-1], a[0]
            } else {
                a[i], a[size-1] = a[size-1], a[i]
            }
            i++
        }
        return count
    }

这段代码产生这个答案：

好了，本文到此结束，带大家了解了《递归地附加到切片切片》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！