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));
    }
}