热题100 - 46. 全排列

题目描述：

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

示例 1：

输入： nums = [1,2,3]
输出： [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入： nums = [0,1]
输出： [[0,1],[1,0]]

示例 3：

输入： nums = [1]
输出： [[1]]

提示：

• 1 <= nums.length <= 6
• -10 <= nums[i] <= 10
• nums 中的所有整数 互不相同

思路：

我首先知道这道题是个回溯的问题

然后我在想，那就是dfs里调两次dfs咯

第二次调用dfs之前先回撤一下上一个修改罢了。

但是啊，看起来我这么想的话，答案会比我想要的多。

private void dfs(List<List<Integer>> res, Deque<Integer> list, int[] nums, int i) {
    if (list.size() == nums.length) {
        res.add(new ArrayList<>(list));
        return;
    }
    list.offerLast(nums[i]);
    dfs(res, list, nums, i+1);
    list.pollLast();
    list.offerFirst(nums[i]);
    dfs(res, list, nums, i+1);
    list.pollFirst();
}

这说明思路不对了。

重新想。全排列，那是坑找数字呢，还是数字找坑呢？

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list = new LinkedList<>();
        dfs(res, list, nums, 0);
        return res;
    }

    private void dfs(List<List<Integer>> res, List<Integer> list, int[] nums, int index) {
        if (list.size() == nums.length) {
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == -11) continue;
            int temp = nums[i];
            nums[i] = -11;
            list.add(temp);
            dfs(res, list, nums, index+1);
            nums[i] = temp;
            list.remove(list.size()-1);
        }
    }
}

根据回溯的思想，以及dfs里喜欢用for循环遍历数组这件事，我写出了上面的代码。DS老师建议做出如下优化：

你可以通过以下方式优化代码，使其更简洁且安全：

import java.util.ArrayList;
import java.util.List;

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(res, new ArrayList<>(), nums, new boolean[nums.length]);
        return res;
    }

    private void dfs(List<List<Integer>> res, List<Integer> path, int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                used[i] = true;          // 标记已使用
                path.add(nums[i]);       // 添加当前元素
                dfs(res, path, nums, used);
                path.remove(path.size() - 1); // 回溯
                used[i] = false;         // 恢复状态
            }
        }
    }
}

优化点说明：

1. 改用布尔数组标记访问状态
   不再修改原始数组 nums，而是用 boolean[] used 记录元素是否被使用。这避免了潜在的数字冲突（比如原数组包含 -11 时的问题），提升了代码的健壮性。

2. 移除无用参数 index
   原代码中的 index 参数未被实际使用，直接移除以简化参数列表。

3. 优化路径存储结构
   将 LinkedList 改为 ArrayList。由于路径操作（添加和删除）始终在尾部进行，ArrayList 的尾部操作效率更高（add 和 remove 均为摊还 O(1) 时间复杂度）。

4. 代码逻辑更清晰
   直接通过 used[i] 判断元素是否可用，避免了原代码中 nums[i] == -11 的魔术数字（Magic Number），可读性更好。

为什么这样更优？

• 安全性：不修改输入数据，避免副作用。
• 可读性：用 used 数组明确表达状态，逻辑更直观。
• 效率：ArrayList 的尾部操作效率高于 LinkedList 的随机删除。