PermutationsUnique，求全排列，去重

问题描述：给定一个数组，数组里面有重复元素，求全排列。

算法分析：和上一道题一样，只不过要去重。

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;

 public class PermutationsUnique {
     public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
         ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
         permuteUnique(num, 0, result);
         return result;
     }

     private void permuteUnique(int[] num, int start, ArrayList<ArrayList<Integer>> result) {

         if (start >= num.length ) {
             ArrayList<Integer> item = convertArrayToList(num);
             result.add(item);
         }

         for (int j = start; j < num.length; j++) {
             if (containsDuplicate(num, start, j)) {
                 swap(num, start, j);
                 permuteUnique(num, start + 1, result);
                 swap(num, start, j);
             }
         }
     }

     private ArrayList<Integer> convertArrayToList(int[] num) {
         ArrayList<Integer> item = new ArrayList<Integer>();
         for (int h = 0; h < num.length; h++) {
             item.add(num[h]);
         }
         return item;
     }
     //nums[start]和nums[end]交换，如果start-end之间有nums[i]==nums[end],那说明它以前交换过，就不用重复了。
     private boolean containsDuplicate(int[] arr, int start, int end) {
         for (int i = start; i < end; i++) {
             if (arr[i] == arr[end]) {
                 return false;
             }
         }
         return true;
     }

     private void swap(int[] a, int i, int j) {
         int temp = a[i];
         a[i] = a[j];
         a[j] = temp;
     }

     //这种方法和Permutation一样，因为用set了，所以就已经去重了。
     public static List<List<Integer>> permuteUnique2(int[] num) {
         List<List<Integer>> returnList = new ArrayList<>();
         returnList.add(new ArrayList<Integer>());

         for (int i = 0; i < num.length; i++) {
             Set<ArrayList<Integer>> currentSet = new HashSet<>();
             for (List<Integer> l : returnList) {
                 for (int j = 0; j < l.size() + 1; j++) {
                     l.add(j, num[i]);
                     ArrayList<Integer> T = new ArrayList<Integer>(l);
                     l.remove(j);
                     currentSet.add(T);
                 }
             }
             returnList = new ArrayList<>(currentSet);
         }

         return returnList;
     }

     public static void main(String[] args)
     {
         Permutations pt = new Permutations();
         int[] num = {1,2,1,3};
         System.out.println(pt.permute(num).size());
         System.out.println(pt.permute(num));
     }
 }