个人记录-LeetCode 46. Permutations

问题：
Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:

[  [1,2,3],  [1,3,2],  [2,1,3],  [2,3,1],  [3,1,2],  [3,2,1]]

问题要求：得到指定数组的全排列。

代码示例：
1、暴力递归
回忆一下我们通常求全排列的方法。
例如有3个数，它们全排列的大小为：
第1个位置，可以为3个数中的任意一个，共有3种选择；
第2位置，在选完第1个位置的数后，可以为剩下2个数中的任意一个，共有2种选择；
第3个位置，在选完第1个和第2个位置的数后，只有1种选择。
因此，整体共有6种选择。

我们也可以按照这种思路写代码：

public class Solution {    public List<List<Integer>> permute(int[] nums) {        List<List<Integer>> result = new ArrayList<>();        if (nums == null || nums.length < 1) {            return result;        }        //现将数组排序，这样相同的数字排在一起，可以跳过，避免重复结果        Arrays.sort(nums);        //flag记录一个数字是否被选择过        boolean[] flag = new boolean[nums.length];        //path记录每次排列的结果        List<Integer> path = new ArrayList<>();        //无脑暴力递归        permute(nums, path, flag, result);        return result;    }    private void permute(int[] nums, List<Integer> path, boolean[] flag, List<List<Integer>> result) {        //已经完成了所有位置的选择，返回结果        if (path.size() == nums.length) {            result.add(path);            return;        }        boolean first = true;        //prev记录当前位置，上一次选择的数        int prev = -1;        for (int i = 0; i < nums.length; ++i) {            if (!flag[i]) {                if (first) {                    prev = nums[i];                    first = false;                } else {                    //避免在同一个位置，选择相同的数，避免重复                    if (nums[i] == prev) {                        continue;                    }                    prev = nums[i];                }                //生成新的位图                List<Integer> tempList = new ArrayList<>(path);                boolean[] tempFlag = new boolean[nums.length];                System.arraycopy(flag, 0, tempFlag, 0, nums.length);                //添加本次信息                tempFlag[i] = true;                tempList.add(nums[i]);                //继续递归                permute(nums, tempList, tempFlag, result);            }        }    }}

2、改进
前一种方法选择每个位置的数时，需要判断其它数是否已经被选择过，比较耗费时间。这种过程我们称为“为位置选数”。

下面这个过程，可以称为“为数选位置”。
第1个数与后续每个数交换位置，得到新数组后，在新数组的基础上递归。
此时，第1个数分别放到了0～n-1的位置上。

然后，开始为第2个数选位置。
由于第1个数和第2个数交换过，因此已经有一个递归序列，处理第2个数放到第1个位置的情况了。
为了避免重复，将第2个数与其后的每个数交换位置，得到下一个新数组，然后继续在此基础上递归。
此时，第2个数分别放在了1～n-1的位置上。

以此类推，得到最终结果。
不过这种方式会有重复的结果。

public class Solution {    public List<List<Integer>> permute(int[] nums) {        List<List<Integer>> result = new ArrayList<>();        //仍然排序，避免重复        Arrays.sort(nums);        //迭代        perm(result,nums,0,nums.length-1);        return result;    }    public static void perm(List<List<Integer>> result, int[] nums, int start, int end) {        //start记录此次交换的起始位置        if(start == end){            Integer[] tempNums = new Integer[nums.length];            for (int i = 0; i < nums.length; ++i) {                tempNums[i] = nums[i];            }            result.add(Arrays.asList(tempNums));        } else {            boolean flag = true;            int prev = -1;            for(int i=start; i<=end; i++){                //以下这一段仍是避免重复                if (flag) {                    prev = nums[i];                    flag = false;                } else {                    //prev与nums[i]的比较，与1方法类似，避免重复交换                    //nums[start]与nums[i]比较，避免某个位置与起始位置一致                    if (prev == nums[i] || nums[start] == nums[i]) {                        continue;                    } else {                        prev = nums[i];                    }                }                //交换当前起始位置和后续位置的数                int temp = nums[start];                nums[start] = nums[i];                nums[i] = temp;                //继续迭代                perm(result, nums,start+1,end);                //还原数组                temp = nums[start];                nums[start] = nums[i];                nums[i] = temp;            }        }    }}