全排列问题

1、打印一个无重复元素数组的全排列

public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        if (nums==null || nums.length==0) { return ans; }
        permute(ans, nums, 0);
        return ans;
    }

    private void permute(List<List<Integer>> ans, int[] nums, int index) {
        if (index == nums.length) { 
            List<Integer> temp = new ArrayList<>();
            for (int num: nums) { temp.add(num); }
            ans.add(temp);
            return;
        }

        for (int i=index; i<nums.length; ++i) {
                swap(nums, index, i);
                permute(ans, nums, index+1);
                swap(nums, index, i);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int save = nums[i];
        nums[i] = nums[j];
        nums[j] = save;
    }

2、打印一个有重复元素数组的全排列，去掉重复数组。

2.1、用HashSet来判断在这次遍历中是否已经遍历过该元素。

public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        if (nums==null || nums.length==0) { return ans; }
        permute(ans, nums, 0);
        return ans;
    }

    private void permute(List<List<Integer>> ans, int[] nums, int index) {
        if (index == nums.length) { 
            List<Integer> temp = new ArrayList<>();
            for (int num: nums) { temp.add(num); }
            ans.add(temp);
            return;
        }
        Set<Integer> appeared = new HashSet<>();
        for (int i=index; i<nums.length; ++i) {
            if (appeared.add(nums[i])) {
                swap(nums, index, i);
                permute(ans, nums, index+1);
                swap(nums, index, i);
            }
        }
    }

    private void swap(int[] nums, int i, int j) {
        int save = nums[i];
        nums[i] = nums[j];
        nums[j] = save;
    }

2.2、用一个新的数组来标记重复

List<List<Integer>>list =new ArrayList<List<Integer>>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        if(nums==null||nums.length==0)return list;
        if(nums.length==1){
            list.add(changeToList(nums));
            return list;
        }
        Arrays.sort(nums);
        deal(0,nums);
        return list;
    }

    public void deal(int i,int[] nums){
        if(i>=nums.length-1){
            list.add(changeToList(nums));
            return;
        }
        for(int j=i;j<=nums.length-1;j++){
            if(j!=i&&nums[j]==nums[i])continue;
            swap(nums,i,j);
            deal(i+1,Arrays.copyOf(nums, nums.length));
        }
    }

    public List<Integer> changeToList(int []nums){
        List<Integer> subList=new ArrayList<Integer>();
        for(int i=0;i<nums.length;i++){
            subList.add(nums[i]);
        }
        return subList;
    }

    public void swap(int []nums,int i,int j){
        if(i==j)return;
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }

用有序的数组过滤重复的元素，要确保每交换一次除了开始元素，后面的元素是有序的。例如数组A={1,2,2,3}，
i=0时的数组为1，2，2，3
i=1时的数组为2，1，2，3（后三个是有序的）
i=2时发现2=2，继续向下遍历
i=3时的数组为3，1，2，2（后三个是有序的）
如果用情况1的swap(nums, index, i);permute(ans, nums, index+1);swap(nums, index, i);每一次两个元素交换后又被交换回来，这时数组是无序的，不能应用上述所说的方法。

3、打印一个1到n的第k个全排列。例如1，2，3的全排列依次为{1，2，3}，{1，3，2}，{2，1，3}，{2，3，1}，{3，1，2}，{3，2，1}，因此第3个排列为{2，1，3}。
如上述例子所说，所有的全排列如下所示：
1+{2,3}；2+{1,3}；3+{1,2}
以1或2或3开头的排列各有2个，因此k=3，一定是以2开头的排列。去掉以1开头的2个排列，则只需求出以2开头的第一个排列，则是{2，1，3}。

public String getPermutation(int n, int k) {
    int pos = 0;
    List<Integer> numbers = new ArrayList<>();
    int[] factorial = new int[n+1];
    StringBuilder sb = new StringBuilder();

    // create an array of factorial lookup
    int sum = 1;
    factorial[0] = 1;
    for(int i=1; i<=n; i++){
        sum *= i;
        factorial[i] = sum;
    }
    // factorial[] = {1, 1, 2, 6, 24, ... n!}

    // create a list of numbers to get indices
    for(int i=1; i<=n; i++){
        numbers.add(i);
    }
    // numbers = {1, 2, 3, 4}

    k--;

    for(int i = 1; i <= n; i++){
        int index = k/factorial[n-i];
        sb.append(String.valueOf(numbers.get(index)));
        numbers.remove(index);
        k-=index*factorial[n-i];
    }

    return String.valueOf(sb);
}

4、输出一个排列的下一个排列。例如{1,2,3}的下一个排列是{1,3,2}

public void nextPermutation(int[] A) {
    if(A == null || A.length <= 1) return;
    int i = A.length - 2;
    while(i >= 0 && A[i] >= A[i + 1]) i--; // Find 1st id i that breaks descending order
    if(i >= 0) {                           // If not entirely descending
        int j = A.length - 1;              // Start from the end
        while(A[j] <= A[i]) j--;           // Find rightmost first larger id j
        swap(A, i, j);                     // Switch i and j
    }
    reverse(A, i + 1, A.length - 1);       // Reverse the descending sequence
}

public void swap(int[] A, int i, int j) {
    int tmp = A[i];
    A[i] = A[j];
    A[j] = tmp;
}

public void reverse(int[] A, int i, int j) {
    while(i < j) swap(A, i++, j--);
}