Permutations，全排列

Posted 2020-07-22 32ddd

问题描述：给定一个数组，数字中数字不重复，求所有全排列。

算法分析：可以用交换递归法，也可以用插入法。

递归法：例如，123，先把1和1交换，然后递归全排列2和3，然后再把1和1换回来。1和2交换，全排列1和3，再把1和2交换回来。1和3交换，全排列2和1，再把1和3交换回来。

 1 //递归方法
 2     public List<List<Integer>> permute2(int[] num) {
 3         List<List<Integer>> result = new ArrayList<>();
 4         permute(num, 0, result);
 5         return result;
 6     }
 7      
 8     void permute(int[] num, int start, List<List<Integer>> result) {
 9      
10         if (start == num.length)
11         {
12             ArrayList<Integer> item = convertArrayToList(num);
13             //List<int[]> list = Arrays.asList(num);这个方法适合String，而不适合int，会把int[]当成一个元素加入list
14             result.add(item);
15         }
16         for (int j = start; j < num.length; j++)
17         {
18             //递归方法，首先1和1交换，求除nums[1]外的序列的全排列，然后1和1再交换回来。1和2交换，求除了nums[1]之外的序列的全排列，然后1和2再交换回来。
19             swap(num, start, j);
20             permute(num, start + 1, result);
21             swap(num, start, j);
22         }
23     }
24      
25     private ArrayList<Integer> convertArrayToList(int[] num) {
26         ArrayList<Integer> item = new ArrayList<Integer>();
27         for (int h = 0; h < num.length; h++) {
28             item.add(num[h]);
29         }
30         return item;
31     }
32      
33     private void swap(int[] a, int i, int j) {
34         int temp = a[i];
35         a[i] = a[j];
36         a[j] = temp;
37     }

 

 

插入法：例如123，1开始有1个插入位置得到序列[1]，然后2有两个插入位置，得到序列[2,1],[1,2]，然后3有三个插入位置，得到[3,2,1],[2,3,1],[2,1,3],[3,1,2],[1,3,2],[1,2,3]

 

 1 public List<List<Integer>> permute(int[] num) {
 2         List<List<Integer>> result = new ArrayList<>();
 3         //start from an empty list
 4         result.add(new ArrayList<Integer>());
 5      
 6         for (int i = 0; i < num.length; i++)
 7         {
 8             List<List<Integer>> current = new ArrayList<>();
 9      
10             for (List<Integer> l : result) 
11             {
12                 //插入size+1个位置
13                 for (int j = 0; j < l.size()+1; j++)
14                 {
15                     l.add(j, num[i]);
16                     ArrayList<Integer> temp = new ArrayList<Integer>(l);
17                     current.add(temp);
18                     l.remove(j);
19                 }
20             }
21      
22             result = new ArrayList<>(current);
23         }
24      
25         return result;
26     }