组合全排列算法

题目一
/**
 * 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 * <p>
 * 说明：解集不能包含重复的子集。
 * <p>
 * 示例:
 * <p>
 * 输入: nums = [1,2,3]
 * 输出:
 * [
 * [3],
 * [1],
 * [2],
 * [1,2,3],
 * [1,3],
 * [2,3],
 * [1,2],
 * []
 * ]
 */

public class Solution3 {
  List<List<Integer>> result = new ArrayList<>();
  int[] nums = {1, 2, 3};

  public static void main(String[] args) {
    Solution3 solution3 = new Solution3();
    ArrayList<Integer> numbers = new ArrayList<>();
    Arrays.sort(solution3.nums);
    solution3.backTracking(solution3.nums, numbers, 0);

    for (List<Integer> child : solution3.result) {
      System.out.println(child.toString());
    }
  }

  private void backTracking(int[] nums, List<Integer> numbers, int start) {
    result.add(new ArrayList<>(numbers));
    for (int i = start; i < nums.length; i++) {
      numbers.add(nums[i]);
      backTracking(nums, numbers, i + 1);
      numbers.remove(numbers.size() - 1);
    }
  }
}

 题目二

/**
 * 给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 * <p>
 * 说明：解集不能包含重复的子集。
 * <p>
 * 示例:
 * <p>
 * 输入: [1,2,2]
 * 输出:
 * [
 * [2],
 * [1],
 * [1,2,2],
 * [2,2],
 * [1,2],
 * []
 * ]
 */

public class Solution4 {
  List<List<Integer>> result = new ArrayList<>();
  int[] nums = {1, 2, 2};

  public static void main(String[] args) {
    Solution4 solution3 = new Solution4();
    ArrayList<Integer> numbers = new ArrayList<>();
    Arrays.sort(solution3.nums);//从小到大排序一下
    solution3.backTracking(solution3.nums, numbers, 0);

    for (List<Integer> child : solution3.result) {
      System.out.println(child.toString());
    }
  }

  private void backTracking(int[] nums, List<Integer> numbers, int start) {
    result.add(new ArrayList<>(numbers));
    for (int i = start; i < nums.length; i++) {
      if (i > start && nums[i] == nums[i - 1]) {//因为已经排序
        continue; // skip duplicates
      }
      numbers.add(nums[i]);
      backTracking(nums, numbers, i + 1);
      numbers.remove(numbers.size() - 1);
    }
  }
}

题目三

/**
 * 给定一个没有重复数字的序列，返回其所有可能的全排列
 * <p>
 * 输入: [1,2,3]
 * 输出:
 * [
 * [1,2,3],
 * [1,3,2],
 * [2,1,3],
 * [2,3,1],
 * [3,1,2],
 * [3,2,1]
 * ]
 */

public class Solution5 {
  List<List<Integer>> result = new ArrayList<>();
  int[] nums = {1, 2, 3};

  public static void main(String[] args) {
    Solution5 solution3 = new Solution5();
    ArrayList<Integer> numbers = new ArrayList<>();
    //    Arrays.sort(solution3.nums);//不需要排序
    solution3.backTracking(solution3.nums, numbers);

    for (List<Integer> child : solution3.result) {
      System.out.println(child.toString());
    }
  }

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

题目四

/**
 * 给定一个有重复数字的序列，返回其所有可能的全排列
 * <p>
 * 输入: [1,1,2]
 * 输出:
 * [
 * [1,1,2],
 * [1,2,1],
 * [2,1,1]
 * ]
 */

public class Solution6 {
  List<List<Integer>> result = new ArrayList<>();
  int[] nums = {1, 1, 2};

  public static void main(String[] args) {
    Solution6 solution3 = new Solution6();
    ArrayList<Integer> numbers = new ArrayList<>();
    Arrays.sort(solution3.nums);
    solution3.backTracking(solution3.nums, numbers, new boolean[solution3.nums.length]);

    for (List<Integer> child : solution3.result) {
      System.out.println(child.toString());
    }
  }

  private void backTracking(int[] nums, List<Integer> numbers, boolean[] used) {
    if (numbers.size() == nums.length) {
      result.add(new ArrayList<>(numbers));
    } else {
      for (int i = 0; i < nums.length; i++) {
        if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) {
          continue;
        }
        used[i] = true;
        numbers.add(nums[i]);
        backTracking(nums, numbers, used);
        used[i] = false;
        numbers.remove(numbers.size() - 1);
      }
    }
  }
}