Pointers 递归地追加到切片的切片

我试图在Go中实现一个简单的函数，它返回一组数字的所有排列。我让它打印所有的排列，但我不能让它附加到二维切片。 这是排列的代码：

主程序包
输入“fmt”
//用堆算法生成置换
func-heapperstation（p*[[]int，a[]int，size，n，count int）int{
计数++
//如果大小变为1，则打印获得的
//排列
如果大小==1{
fmt.Println（a）
*p=附加（*p，a）
返回计数
}
i:=0
对于我<尺寸{
count=HEAPPER突变（p，a，大小-1，n，count）
//如果大小为奇数，则交换第一个和最后一个
//元素
//否则，如果大小为偶数，则交换第i个和最后一个元素
如果大小%2！=0{
a[0]，a[size-1]=a[size-1]，a[0]
}否则{
a[i]，a[size-1]=a[size-1]，a[i]
}
我++
}
返回计数
}

这是主要功能：

func main（）{
列表编号：=[]整数{1,2,3}
n:=len（列表编号）
排列：=make（[]int，0）
p:=&置换
heapermutation（p，listNumbers，n，n，0）
格式打印（排列）
}

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

[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]]

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

---

谢谢

您没有将不同的

[]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））
副本（tmp，a）
*p=追加（*p，tmp）

---

阅读更多关于

copy

好的，在@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
    }

导入“fmt”
//用堆算法生成置换
func-heapperstation（p*[[]int，a[]int，size，n，count int）int{
计数++
//如果大小变为1，则打印获得的
//排列
如果大小==1{
fmt.Println（a）
tmp:=make（[]整数，len（a））
/*
“a”就像指向对象的指针，
每次修改“a”时，它都会更改“a”的所有元素
在排列列表中。
像这样
:
a:=[]int{1}
p:=[]int{a，a，a}
fmt.Println（p）/[1][1][1]
a[0]=2
fmt.Println（p）/[[2][2][2]]
*/
副本（tmp，a）
*p=追加（*p，tmp）
格式打印项次（*p）
返回计数
}
i:=0
对于我<尺寸{
count=HEAPPER突变（p，a，大小-1，n，count）
//如果大小为奇数，则交换第一个和最后一个
//元素
//否则，如果大小为偶数，则交换第i个和最后一个元素
如果大小%2！=0{
a[0]，a[size-1]=a[size-1]，a[0]
}否则{
a[i]，a[size-1]=a[size-1]，a[i]
}
我++
}
返回计数
}

此代码生成以下答案：

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

---

嘿，非常感谢你详细的回答。首先，你认为我应该把你建议的代码放在哪里？其次，我仍然不明白一个append语句如何修改所有的切片元素？好的，我再次阅读了你的评论，我明白了你的意思。我现在可以用了，谢谢！