lecture-7 递归

1、例题--排列 Permutation 
Given a collection of distinct numbers, return all possible permutations.
For example,
[1,2,3] have the following permutations:
[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].
public List<List<Integer>> permute(int[] nums) {
// Implement this method.
}

1）边界条件：组合问题，输入为空，输出为空；其他情况都是正常的。

2）思路：第一个位置先选一个数，第二位置从剩下的两个数里面选一个数，第三个位置只能选最后一个数。

那么N个数的Level-N问题这样化简：第一个位置从N个数里面选择一个，剩余N-1位置和N-1个数，生成一个Level-(N-1)的问题，形成递归。

3）代码实现

public List<List<Integer>> permute(int[] nums) {
　　List<List<Integer>> numList = new ArrayList<Integer>(); ///错误的new ArrayList<ArrayList<Integer>>()

　　Arrays.sort(nums);//排序有什么用？跟大小没有关系.. 有重复数字的情况会有用。

　　for (int i = 0 ; i < nums.length; i++) {

　　　　numList.add(nums[i]);  ///将数组转换为Arraylist，方便后面操作

　　}

　　 return permutes(new ArrayList<Integer>(); numList);

}

　　/*先实现递归函数主体*/

　　public List<List<Integer>> permutes(ArrayList<Integer> cur, ArrayList<Integer> nums) {

　　　　List<List<Integer>> results = new ArrayList<ArrayList<Integer>>();

　　　　if (0 == nums.size()) {

　　　　　　///ArrayList<Integer> result = new ArrayList<>(cur);  ///不需要这一行，因为上一层函数已经申请了新的内存空间

　　　　　　results.add(result);

　　　　　　return results;

　　　　}

　　　　for (int i = 0; i < nums.size(); i++) {

　　　　　　List<Integer> newCur = new ArrayList<>(cur);

　　　　　　newCur.add(nums.get(i));

　　　　　　List<Integer> newNum = new ArrayList<>(nums);

　　　　　　newNums.remove(i);

　　　　　    result.addAll(permutes(newCur, newNum));

　　　　}

　　　　return results;

　　}

4）时间复杂度：O(n!)；空间复杂度：O(n!)---空间复杂度似乎不准

5）其他解法

a)

public List<List<Integer>> permute(int[] nums) {
　　List<List<Integer>> numList = new List<Integer>();

　　for (int i = 0 ; i < nums.length; i++) {

　　　　numList.add(nums[i]);

　　}

　　 return permutes(new List<Integer>(); numList);

}

public List<List<Integer>> permutes(List<Integer> cur, List<Integer> num) {

　　List<List<Integer>> results = new ArrayList<Integer>();

　　if (0 == num.size()) {

　　　　List<Integer> result = new ArrayList<Integer>(cur); //这里申请新内存保持结果，因为上层函数没有申请，只有一个cur在传递。

　　　　results.add(result);///可以简化一下 results.add(new ArrayList<Integer>(cur))

　　　　return results;

　　}

　　for (int i = 0; i < num.size(); i++) {

　　　　cur.add(num.get(i));

　　　　num.remove(i);

　　　　results.addAll(permutes(cur, num));

　　　　num.add(cur.get(cur,size() - 1));///没有申请新内存，所以要恢复现场

　　　　cur.remove(cur.size() - 1);

　　}

　　return results;

}

b)

public ArrayList<ArrayList<Integer>> permute(int[] num) {

　　ArrayList<ArrayList<Integer>> results = new ArrayList<Integer>();

　　Arrays.sort(nums);

　　return permutes(new ArrayList<Integer>(), nums);

}

public ArrayList<ArrayList<Integer>> permutes(ArrayList<Integer> cur, int[] nums) {

　　ArrayList<ArrayList<Integer>> results = new ArrayList<Integer>();

　　if (cur.size() == nums.length) {

　　　　ArrayList<Integer> result = new ArrayList<Integer>(cur);

　　　　results.add(result); ///可以简化一下 results.add(new ArrayList<Integer>(cur))

　　　　return results;

　　}

　　for (int i = 0; i < nums.length; i++) {

　　　　if (!cur.contains(nums[i])) {

　　　　　　cur.add(num[i]);

　　　　　　results.addAll(permutes(cur, nums));

　　　　　　cur.remove(cur.size() - 1);　　　

　　　　}

　　}

}

c)Use the num array to serve as the "cur"

[0..index-1] means we have already set the first index
numbers
[index..length-1] are the numbers that we haven't set
Example: [4, 3, 5, 8, 1]
choose 8, then swap (4, 8) => [8, 3, 5, 4, 1]
choose 3, do nothing => [8, 3, 5, 4, 1]
choose 1, then swap (5, 1) => [8, 3, 1, 4, 5]
choose 5, then swap (4, 5) => [8, 3, 1, 5, 4]
choose 4, do nothing, => [8, 3, 1, 5, 4]

public ArrayList<ArrayList<Integer>> permute(int[] nums) {

　　ArrayList<ArrayList<Integer>> results = new ArrayList<Integer>();

　　Arrays.sort(nums);

　　permutes(results, nums, 0);

　　return results;

}

public void permutes(ArrayList<ArrayList<Integer>> results, int[] nums, int index) {

　　if (index == nums.length) {

　　　　ArrayList<Integer> result = new ArrayList<>();
　　　　for (int i = 0; i < nums.length; i++) {

　　　　　　result.add(nums[i]);

　　　　}

　　　　results.add(result);

　　　　return;

　　}

　　for (int i = index; i < nums.length; i++) {

　　　　swap(nums, index, i);

　　　　permutes(results, nums, index + 1);

　　　　swap(nums, i, index);　　　　

　　}

　　return;

}

public void swap(int[] nums, int i, int j)

2、组合--Combination

Given a collection of distinct numbers, return all possible combinations.
For example,
[2, 6, 8] have the following permutations:
[], [2], [6], [8], [2, 6], [2, 8], [6, 8], [2, 6, 8].
public List<List<Integer>> combine(int[] nums) {
// Implement this method.
}

1）边界条件：空集合；输入为空能在正常流程里面处理吗？

2）思路：对于第一个数2有两种情况，选择或者不选择；然后再对[6,8]进行组合。那么对于Level-N的问题，先对第一个数进行选择/不选择，然后对剩余N-1个数进行组合，这样就化为Level-(N-1)，形成了递归。

3）代码实现：

public List<List<Integer>> combine(int[] nums) {

　　return combines(new ArrayList<Integer>(), nums, 0);

}

public List<List<Integer>> combines(List<Integer> cur, int[] nums, int index) { ---把结果当做出参

　　List<List<Integer>> results = new ArrayList<>();

　　if (index == nums.length) {

　　　　results.add(new ArrayList<Integer>(cur)); //上一层没有申请内存，这一层申请

　　　　return results;　　

　　}

　　results.addAll(combines(cur, nums, index + 1));

　　cur.add(nums[index]);

　　results.addAll(combines(cur, nums, index + 1));

　　cur.remove(cur.size() - 1); //恢复现场

}

4)时间复杂度：O(2^n)；空间复杂度：O(2^n)?

其他解法：把结果当做入参

public List<List<Integer>> combine(int[] nums) {

　　List<List<Integer>> results = new ArrayList<>();

　　combines(results, new ArrayList<Integer>(), 0);

　　return results;

}

public void combines(List<List<Integer>> results, List<Integer> cur, int[] nums, int index) {

　　if (index == nums.length) {

　　　　results.add(cur);//直接添加，上一层已经申请了新内存。

　　　　return;

　　}

　　List<Integer> newCur1 = new ArrayList<>(cur);

　　combines(results, newCur1, nums, index + 1);

　　List<Integer> newCur2 = new ArrayList<>(cur);//得申请两个新内存，不然也会互相覆盖。申请两个就不用恢复现场了。

　　newCur2.add(nums[index]);

　　combines(results, newCur2, index + 1);

　　return;

}