LeetCode - 全排列

题目：LeetCode-46

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

提示：

• 1 <= nums.length <= 6
• -10 <= nums[i] <= 10
• 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. 选择数组中的一个元素之后，剩余的元素进行全排列即可
2. 对于剩余的元素的全排列可以调用全排列函数即可，所以递归函数的参数中要有数组A，后续进行全排列的数组的开始元素的下标 p，和末尾元素 下标q
3. 那怎么选择某一个元素呢？
4. 可以按顺序进行选择 - 循环遍历要全排列的数组，遍历到每一个元素的时候都要和第一个元素进行交换
5. 交换之后，再对后续的元素进行全排列

注：

• 递归结束条件： 当 p = q 时，递归结束，因为 p = q 时，要全排列的数组只剩一个元素，直接返回即可
• 元素交换之后，在此次递归结束之后，要把交换后的元素再交换回来，不然会出现有重复排列的情况 

A ：[ 1, 2, 3, 4 ]

对于 1 开头的所有排列：1234 、1243、1324 、 1342 、 1423 、 1432

（A[0] 和 A[0] 交换后，剩余的元素[ 2, 3, 4 ]进行全排列， p = 1， q = A.length-1）

如果交换之后没有交换回来会出现：

① 1 2 3 4 --- A[1] 和 A[1] 交换后，[3,4]全排列

                     [3,4] ----- A[2] 和 A[2] 交换之后 [4] 全排列，剩1个元素，直接返回到上一层递归

② 1 2 4 3 --- [4,3] ----- A[2] 和 A[3] 交换之后[3]全排列，剩1个元素，直接返回到上一层递归

                     这一次循环结束

③ 1 4 2 3 --- A[1] 和 A[2] 交换后，[2,3]全排列，和上一步一样

④ 1 4 3 2 

⑤ 1 2 3 4 --- A[1] 和 A[3] 交换后，就出现了重复，和 ① 重复了

交换之后交换回来就不会出现重复的情况了：

因为每次结束一次排列，开始下一次排列的时候，A 都是 [ 1 , 2 , 3 , 4 ]

① 1 2 3 4 --- A[1] 和 A[1] 交换后，[3,4]全排列

                     [3,4] ----- A[2] 和 A[2] 交换之后 [4] 全排列，剩1个元素，直接返回到上一层递归

② 1 2 4 3 --- [4,3] ----- A[2] 和 A[3] 交换之后[3]全排列，剩1个元素，直接返回到上一层递归

                     这一次循环结束

③ 1 3 2 4 --- A[1] 和 A[2] 交换后，[2,3]全排列，和上一步一样

④ 1 3 4 2 

⑤ 1 4 3 2 --- A[1] 和 A[3] 交换后，[3,2]全排列，和上一步一样

⑥ 1 4 2 3

没有重复的情况出现

2 开头的所有排列，是将 A[0] 和 A[1] 互换之后，[1, 3, 4] 进行全排列得到的

以此类推，得到所有的排列

算法：

public List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> lists = new LinkedList<>();
    recursion(lists, nums, 0, nums.length-1);
    return lists;
}
void recursion(List<List<Integer>> lists, int[] a, int p, int q){
    if(p == q){
        List<Integer> b = new LinkedList<>();
        for (int i : a){
            b.add(i);
        }
        lists.add(b);
    }
    else{
    for(int i = p; i <= q; i++){
        swap(a, p, i);
        recursion(lists, a, p+1, q);
        swap(a, p, i);
        } 
    }
}
void swap(int[] a, int i, int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

 运行结果：

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

 一些思路：