有很多算法可以生成排列。最简单的例子是Heap's algorithm：
它通过选择一对要交换的元素来从前一个置换生成每个置换。
在上面的链接中概述了一个接一个地打印排列的想法和伪代码。下面是我的算法实现，它返回所有的排列

func permutations(arr []int)[][]int{
    var helper func([]int, int)
    res := [][]int{}

    helper = func(arr []int, n int){
        if n == 1{
            tmp := make([]int, len(arr))
            copy(tmp, arr)
            res = append(res, tmp)
        } else {
            for i := 0; i < n; i++{
                helper(arr, n - 1)
                if n % 2 == 1{
                    tmp := arr[i]
                    arr[i] = arr[n - 1]
                    arr[n - 1] = tmp
                } else {
                    tmp := arr[0]
                    arr[0] = arr[n - 1]
                    arr[n - 1] = tmp
                }
            }
        }
    }
    helper(arr, len(arr))
    return res
}

下面是一个如何使用它的例子（Go playground）：

arr := []int{1, 2, 3}
fmt.Println(permutations(arr))
[[1 2 3] [2 1 3] [3 2 1] [2 3 1] [3 1 2] [1 3 2]]

需要注意的一点是，排列不是按字典顺序排序的（正如您在itertools.permutations中看到的那样）。如果出于某种原因，你需要对它进行排序，我发现的一种方法是从factorial number system生成它们（在permutation section中描述了它，并允许快速找到第n个字典排列）。

**P.S.**你也可以看看其他人的代码here和这里

下面的代码迭代了所有的排列，而没有先生成它们。切片p将中间状态保持为Fisher-Yates混洗算法中的偏移。这有一个很好的性质，即p的零值描述了单位置换。

package main

import "fmt"

func nextPerm(p []int) {
    for i := len(p) - 1; i >= 0; i-- {
        if i == 0 || p[i] < len(p)-i-1 {
            p[i]++
            return
        }
        p[i] = 0
    }
}

func getPerm(orig, p []int) []int {
    result := append([]int{}, orig...)
    for i, v := range p {
        result[i], result[i+v] = result[i+v], result[i]
    }
    return result
}

func main() {
    orig := []int{11, 22, 33}
    for p := make([]int, len(orig)); p[0] < len(p); nextPerm(p) {
        fmt.Println(getPerm(orig, p))
    }
}

var res [][]int
func permute(nums []int) [][]int {
    res=make([][]int,0)
    n:=len(nums)
    var backTrack func(int)
    backTrack=func(first int){
        if first == n{
            temp:=make([]int, n)
            copy(temp,nums)
            res = append(res, temp)
        }
        for i:=first;i<n;i++{
            nums[first],nums[i] = nums[i],nums[first]
            backTrack(first+1)
            nums[first],nums[i] = nums[i],nums[first]
        }
    }
  
    backTrack(0)
    return res
}

在我的例子中，我引用了一个数组，然后我在你的例子中做了一些修改：

func generateIntPermutations(array []int, n int, result *[][]int) {
    if n == 1 {
        dst := make([]int, len(array))
        copy(dst, array[:])
        *result = append(*result, dst)
    } else {
        for i := 0; i < n; i++ {
            generateIntPermutations(array, n-1, result)
            if n%2 == 0 {
                // Golang allow us to do multiple assignments
                array[0], array[n-1] = array[n-1], array[0]
            } else {
                array[i], array[n-1] = array[n-1], array[i]
            }
        }
    }
}
numbers := []int{0, 1, 2}
var result [][]int
generateIntPermutations(numbers, len(numbers), &result)

// result -> [[0 1 2] [1 0 2] [2 1 0] [1 2 0] [2 0 1] [0 2 1]]

另一个工作代码

package permutations

import "fmt"

func AllPermutation(a []int) {
    var res [][]int
    calPermutation(a, &res, 0)
    fmt.Println(res)
}
func calPermutation(arr []int, res *[][]int, k int) {
    for i := k; i < len(arr); i++ {
        swap(arr, i, k)
        calPermutation(arr, res, k+1)
        swap(arr, k, i)
    }
    if k == len(arr)-1 {
        r := make([]int, len(arr))
        copy(r, arr)
        *res = append(*res, r)
        return
    }
}
func swap(arr []int, i, k int) {
    arr[i], arr[k] = arr[k], arr[i]
}
//result [[1 2 3] [1 3 2] [2 1 3] [2 3 1] [3 2 1] [3 1 2]]

下面是另一个变体：

// heap algorithm
func permutations(arr []int, l int, p [][]int) [][]int {
  if l == 1 { p = append(p, append([]int{}, arr...)) }
  for i := 0 ; i < l ; i++ {
    p = permutations(arr, l-1, p)
    if l % 2 == 1 {
      arr[0], arr[l-1] = arr[l-1], arr[0]
    } else {
      arr[i], arr[l-1] = arr[l-1], arr[i]
    }
  }
  return p
}

• 在golang中使用简单算法的排列代码 *

package main

import "fmt"

func permute(arr[] int, start int, end int) {
        if start == end {
                fmt.Println(arr)
                return
        }
        for i:=start;i<end;i++ {
                arr[i],arr[start] = arr[start],arr[i]
                permute(arr,start+1,end)
                arr[i],arr[start] = arr[start],arr[i]
        }
}

func main() {
        arr := []int{1,2,3}
        end := len(arr)
        start := 0
        permute(arr,start,end)
}