LeetCode题练习与总结：全排列

一、题目描述

给定一个不含重复数字的数组 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 中的所有整数 互不相同

二、解题思路

1. 初始化：创建一个 List<List<Integer>> 类型的 results 用于存储所有可能的排列。初始化一个 List<Integer> 类型的 current 用于存储当前的排列。创建一个布尔数组 used 用于标记数组 nums 中的每个元素是否已经被添加到当前排列中。

2. 递归回溯：定义一个私有方法 backtrack，它接受四个参数：results、current、used 和 nums。这个方法将递归地构建所有可能的排列。

3. 基本情况：在 backtrack 方法中，首先检查 current 的大小是否与 nums 的长度相等。如果相等，表示当前排列已经完整，将其添加到 results 中。

4. 递归构建：遍历 nums 数组，对于每个元素，检查它是否已经被使用过（通过 used 数组）。如果未使用，将其标记为已使用，将其添加到 current 中，并递归调用 backtrack 方法来构建剩余元素的排列。

5. 回溯：在每次递归调用 backtrack 之后，执行回溯操作。这意味着从 current 中移除最后一个元素，并将其在 used 数组中的标记重置为未使用。这样做是为了能够在后续的递归中重新使用这个元素。

6. 返回结果：当所有递归调用都完成后，返回 results 列表，它包含了 nums 的所有全排列。

三、具体代码

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

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return results;
        }

        // 用于存储当前排列
        List<Integer> current = new ArrayList<>();
        // 用于标记数组中元素是否已经使用过
        boolean[] used = new boolean[nums.length];

        // 调用回溯函数
        backtrack(results, current, used, nums);

        return results;
    }

    private void backtrack(List<List<Integer>> results, List<Integer> current, boolean[] used, int[] nums) {
        // 如果当前排列的长度等于 nums 的长度，说明找到了一个完整的排列
        if (current.size() == nums.length) {
            results.add(new ArrayList<>(current)); // 添加到结果集
            return;
        }

        // 遍历数组，选择未使用过的元素
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                used[i] = true; // 标记为已使用
                current.add(nums[i]); // 将元素添加到当前排列
                backtrack(results, current, used, nums); // 递归调用回溯函数
                current.remove(current.size() - 1); // 回溯，移除最后一个元素
                used[i] = false; // 标记为未使用，以便其他排列使用
            }
        }
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 对于一个包含 n 个元素的数组，全排列的数量是 n!（n 的阶乘）。这是因为第一个位置有 n 种选择，第二个位置有 n-1 种选择，依此类推，直到最后一个位置只有一种选择。
• 由于每次递归都会固定一个位置的元素，所以每个元素都会被访问一次。因此，对于每个排列，我们都会进行 n 次递归调用。
• 综上所述，算法的总时间复杂度是 O(n * n!)，其中 n 是数组 nums 的长度。但是，由于 n! 远远大于 n，通常我们只关注 n! 这部分，所以时间复杂度可以简化为 O(n!)。
• 需要注意的是，虽然时间复杂度是 O(n!)，但由于 n 的值在本问题的限制条件下（1 <= nums.length <= 6）相对较小，所以实际运行时间是可接受的。而在更一般的情况下，如果 n 的值较大，全排列的时间复杂度将会非常高，不适合直接使用回溯算法求解。

2. 空间复杂度

• 主要取决于递归栈的深度和当前排列的大小。
• 在最坏的情况下，递归栈的深度将达到 n，即数组 nums 的长度，因为我们需要递归 n 次来生成一个完整的排列。
• 当前排列的大小在最坏情况下也会达到 n，因为我们需要存储所有 n 个元素的排列。
• 因此，空间复杂度是 O(n)，这是因为我们需要存储 n 个元素的排列以及递归栈的深度。

五、总结知识点

1. 回溯算法：这是一种通过递归来遍历所有可能的候选解的算法。当探索到某一步时，如果发现当前候选解不能得到有效的全局解，就会回退到上一步，尝试其他的候选解。

2. 递归：递归是一种编程技术，函数自己调用自己的一个实例。在这个代码中，backtrack 方法递归地调用自己来生成所有可能的排列。

3. 数组和列表：代码中使用了 Java 的 int[] 数组来存储原始的数字序列，以及 List<Integer> 来存储当前的排列和结果集中的每个排列。

4. 布尔数组：used 是一个布尔数组，用于跟踪 nums 中的每个元素是否已经被添加到当前排列中，以避免重复使用相同的元素。

5. ArrayList 的使用：ArrayList 是 Java 中的一个动态数组实现，用于存储可变大小的元素列表。在这个代码中，ArrayList 被用来动态添加和移除元素。

6. List 复制：在将当前排列添加到结果集时，代码使用了 new ArrayList<>(current) 来创建 current 列表的一个副本，这样做是为了避免在后续的排列生成过程中修改已经添加到结果集的排列。

7. 条件判断：在递归函数中，通过判断当前排列的大小是否等于 nums 的长度来确定是否找到了一个完整的排列。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。