【LeetCode-中等】46. 全排列（图文详解）

题目

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

题目地址：https://leetcode.cn/problems/permutations/

解法1：回溯算法

思路参考：力扣官方题解、liweiwei

https://leetcode.cn/problems/permutations/solution/hui-su-suan-fa-python-dai-ma-java-dai-ma-by-liweiw/ 

 一边看上图，一边看思路。

深度优先遍历：
        在一个列表的尾部不断的添加元素，添加过的元素将其布尔数组对应值变成false，表示使用过了，下一次添加将不会添加使用过的数。
        当一个list添加满了，就将其添加到结果List中。然后再寻找下一个list。

例如

推荐一边看代码，一边看图，一边看解析。

上图，数组是【1,2,3】：

1. 开始递归：判断列表是否满，没满，先选择“1”，然后将“1”对应的布尔数组中设置为true，表示1 已经被使用了。开始递归下一层，也就是层数+1，表示列表已经有1个数，这时链表是“1”。
2. 开始递归：判断列表是否满，没满，继续添加，因为“1”添加过了，往后走，添加“2”，然后将“2”对应布尔数组的位置设置为true，表示“2”已经被使用了。开始递归下一层，层数再+1，表示列表已经有2个数，这时链表是“1，2”。
3. 开始递归：判断列表是否满，没满，继续添加，因为“1”、“2”添加过了，往后走，添加“3”，然后将“3”对应布尔数组的位置设置为true，表示“3”已经被使用了。开始递归下一层，层数再+1，表示列表已经有3个数，这时链表是“1，2，3”。
4. 开始递归：判断列表是否满，满了，将结果“1,2,3”添加到最后的结果list中，结束这次递归。
5. 开始回溯，也就是回到了第3步的递归之后的代码，撤销：删掉链表最后一个数“3”，再将“3”设置为没使用过，这时链表是“1，2”。因为现在for循环已经执行到了i=3，所以结束这次的递归。
6. 开始回溯，也就是回到了第2步的递归之后的代码，撤销：删掉链表最后一个数“2”，再将“2”设置为没使用过。这时链表是“1”。因为现在for循环执行到了i=2，所以开始下一轮循环i=3。添加“3”，然后将“3”对应布尔数组的位置设置为true，这时链表是“1，3”表示“3”已经被使用了。开始递归下一层，层数再+1，表示列表已经有2个数。
7. 开始递归：判断列表是否满，没满，继续添加，因为“1”添加过了，“2”没有添加，添加“2”，然后将“2”对应布尔数组的位置设置为true，表示“2”已经被使用了。这时链表是“1，3，2”开始递归下一层，层数再+1，表示列表已经有3个数。
8. 开始递归：判断列表是否满，满了，将结果“1,3,2”添加到最后的结果list中，结束这次递归。。
9. 后面就和上图一样继续递归+循环

class Solution {
    //将最后的结果设置为全局变量，方便递归的操作，也可以设置为递归的参数，但那样为觉得递归的参数太多了不美观。
    List> res = new ArrayList>();

    public List> permute(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return res;
        }
        List list = new ArrayList();
        boolean[] used = new boolean[len];//初始化布尔数组都是false
        dfs(nums, len, 0,used, list);
        return res;

    }

    /**
     *深度优先遍历：
     * 在一个列表的尾部不断的添加元素，添加过的元素将其布尔数组对应值变成false，表示使用过了，下一次添加将不会添加使用过的数
     * 当一个List添加满了，就将其添加到结果List中
     *
     * @param nums 传入的数组
     * @param len 数组长度
     * @param depth 递归到了第几层，也就是当前已经选了几个数了
     * @param used 布尔数组，表示是否使用过。以空间换取时间。true：使用过了。false：没被使用。
     * @param list 用于放一个结果的list
     */
    void dfs(int[] nums, int len, int depth, boolean[] used, List list)  {
        //递归终止条件
        if (depth == len) {//当递归的深度 = 数组的长度的时候：说明我们的list已经满了，一个结果已经有了，直接上传
            res.add(new ArrayList<>(list));//添加的时候，添加的是拷贝的List
            return;
        }
        for (int i = 0; i < len; i++) {
            if (used[i]) {//如果当前这个数已经被使用过，那就跳过
                continue;
            }//否则，没有使用过
            list.add(nums[i]);//添加这个数
            used[i] = true;//在布尔数组used中将其变成true，表示使用过了
            dfs(nums, len, depth + 1, used,list);//递归到下一层，只有层数：“depth”参数改变，其他参数不变
            //回溯：前面做了什么，后面就要撤销这些操作
            list.remove(list.size()-1);//删除最后面这个数
            used[i] = false;//在布尔数组used中将其变成false，表示没被使用
        }
    }
}

总结

回溯算法确实难，但多练几遍，多思考就会了，如果你第一次就写出来了，那你确实厉害，如果没有写出来，那也不必灰心，大部分人都是看题解看多了才会的。