46. Permutations

Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3]
Output:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

解析

給定一個數組（沒有重復元素），返回所有可能的排序。

參考答案

自己寫的：

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> lists = new LinkedList<>();
        addList(nums, lists, new ArrayList<>());
        return lists;
    }
    
    public void addList(int[] nums, List<List<Integer>> lists, List<Integer> list) {
        if (list.size() == nums.length) {
            lists.add(list);
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!list.contains(nums[i])) {
                List newList = new ArrayList<>(list);
                newList.add(nums[i]);
                addList(nums, lists, newList);
            }
        }
    }
}
 

別人寫的：

class Solution {
    public List<List<Integer>> permute(int[] nums) {
       List<List<Integer>> list = new ArrayList<>();
       // Arrays.sort(nums); // not necessary
       backtrack(list, new ArrayList<>(), nums);
       return list;
     }

    private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums){
       if(tempList.size() == nums.length){
          list.add(new ArrayList<>(tempList));
       } else{
          for(int i = 0; i < nums.length; i++){ 
             if(tempList.contains(nums[i])) continue; // element already exists, skip
             tempList.add(nums[i]);
             backtrack(list, tempList, nums);
             tempList.remove(tempList.size() - 1);
          }
       }
    }
}
 

我的答案是簡單粗暴的，遞歸遍歷找到數組每個位置上可能的數字，然後復制上次的數組，加上新的位置上可能存在的數字然後用新的數組進行下個位置的查詢，效率低，主要是因為每次叠代都要復制數組。

別人這裏用了回朔，一直到到最終結果才會復制數組，然後回退，尋找下個結果，沒有再向上回退，一直到最上面的遞歸執行完畢，就對所有結果查找完畢。下面畫了兩種方法的流程圖，幫助理解。

不用回朔的情況：

每層遞歸都要復制數組，效率低下。

用回朔的情況：

底層遞歸執行完之後返回上層，上層會刪除底層增加的元素，然後繼續遍歷，不需要復制數組，只會在最終得到結果時，復制數組，加入結果數組。

[leetcode][46] Permutations