LeetCode--046--全排列(java)

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

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

无奈，用swap的方法从左向右滑动，直到最后结果和最初的一致停止，只适用于三位数。。。。(改进一下让每个数字作为第一位后面的进行滑动，应该可以pass,放弃)

错：

 class Solution {
     public static void swap(int[] nums_,int a,int b){
             int temp = nums_[a];
             nums_[a] = nums_[b];
             nums_[b] = temp;
         }
     public static boolean isEqual(int[] a,int[] b){
         for(int i = 0;i < a.length;i++){
             if(a[i] != b[i])return false;
         }
         return true;
     }
     public List<List<Integer>> permute(int[] nums) {
         List<List<Integer>> res = new ArrayList();
             List<Integer> lists = new ArrayList();
             if(nums.length < 2){
                 lists.add(nums[0]);
                 res.add(lists);
                 return res;
             }
             int[] nums_ = new int[nums.length];
             for(int k = 0;k < nums.length;k++){
                 nums_[k] = nums[k];
                 lists.add(nums[k]);

             }
             res.add(new ArrayList(lists));
             lists.removeAll(lists);
             swap(nums_,0,1);
             for(int j = 0;j < nums.length;j++){
                 lists.add(nums_[j]);
             }
             res.add(new ArrayList(lists));
             int i = 1;
             while(!isEqual(nums,nums_)){
                 if(i+1<nums.length){
                     swap(nums_,i,i+1);
                     if(!isEqual(nums,nums_)){
                         lists.removeAll(lists);
                         for(int j = 0;j < nums.length;j++){
                             lists.add(nums_[j]);
                         }
                         res.add(new ArrayList(lists));
                     }
                     i++;
                 }else{
                     i = 0;
                 }
             }
             return res;
     }

 }

正确做法bt:  添加顺序就是[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]

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

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

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

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

TIME:O(N!*N)(整体来说)

SPACE:O(N)

 class Solution {

     public List<List<Integer>> permute(int[] nums) {
         List<List<Integer>> res = new ArrayList<>();
         if(nums== null || nums.length ==0)return res;
         helper(res,new ArrayList<>(),nums);
         return res;
     }
     public void helper(List<List<Integer>> res,List<Integer> list,int[] nums){
         if(list.size() == nums.length){
             res.add(new ArrayList<>(list));
             return;
         }
         for(int i = 0;i < nums.length;i++){
             if(list.contains(nums[i]))continue;//contaisn的时间复杂度为O(N)
             list.add(nums[i]);
             helper(res,list,nums);
             list.remove(list.size()-1);
         }
     } 

 }

如果递归符合T(n) = T(n-1)+T(n-2)+....T(1)+T(0)  时间复杂度基本符合O(2^n),如果在其中的一些步骤可以省略，则可以简化为O(n!)

对于方法1思想的完善：

TIME:O(N)

SPACE:O(N)

 class Solution {

     public List<List<Integer>> permute(int[] nums) {
         List<List<Integer>> res = new ArrayList<>();
         if(nums.length == 0 || nums == null)return res;
         helper(res,0,nums);
         return res;
     }
     public void helper(List<List<Integer>> res,int start,int[] nums){
         if(start == nums.length){
             List<Integer> list = new ArrayList<>();
             for(int q:nums){
                 list.add(q);
             }
             res.add(new ArrayList<>(list));
             return;
         }
         for(int i = start;i < nums.length;i++){
             swap(nums,start,i);
             helper(res,start+1,nums);
             swap(nums,start,i);
         }

     }
     public void swap(int[] nums,int l,int m){
         int temp = nums[l];
         nums[l] = nums[m];
         nums[m] = temp;
     }

 }

2019-05-04 10:45:10