JS全排列 Permutations 回溯算法 DFS 交换法实现

全排列

给定一个没有重复的数字序列，返回其所有可能的全排列
输入[1,2,3]
输出[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
 ]

回溯算法

      // 回溯算法，dfs
    let permute = nums => {
            // res储存所有组合系列
            let res = []
            dfs([])

            function dfs(path) {
                // 走到最底下(单个全排列完)还未被回溯舍去，表示通过，放入res
                if (path.length === nums.length) {
                    return res.push([...path])
                }
                for (let i = 0; i < nums.length; i++) {
                    // 回溯，找父级以上是否有当前相同节点，有就舍去
                    if (path.includes(nums[i])) {
                        continue
                    }
                    // 没有相同节点，将他放入path继续往下组合
                    path.push(nums[i])
                    dfs(path)
                    // 回退上一级 选择另外一个节点进行继续往下
                    path.pop()
                }
            }

            return res
        }
    let result = permute([1, 2, 3])
    console.log(result)

算法运算过程

解释补充

结果

交换法

function permute2(nums) {
        // 储存所有集合系列
        let res = []
        // 交换两个元素的值
        function swap(p, q) {
            if (p === q) {
                return
            }
            [nums[p], nums[q]] = [nums[q], nums[p]]
        }
        function dfs(p, q) {
            // 到了最底层
            if (p === q) {
                res.push([...nums])
                return
            }
            // 挨个段进行交换  dfs  交换
            for (let i = p; i <= q; i++) {
                swap(p, i)
                dfs(p + 1, q)
                swap(p, i)
            }
        }
        dfs(0, nums.length - 1)
        return res
    }
    let result2 = permute2([1, 2, 3])
    console.log(result2)

算法过程

结果