leetcode 77. 组合 & 46. 全排列

单独挑出这两题，其实是想说下排列和组合在代码中在哪些地方不同。
排列因为与顺序有关，所以回溯backtracking时，index 从0开始，而组合与顺序无关，所以index可以直接直接记录一个start，每次开始与start有关。
77. 组合

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

代码

public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> combinations = new ArrayList<>();
        List<Integer> combineList = new ArrayList<>();
        backtracking(combineList, combinations, 1, k, n);
        return combinations;
    }
    private  void backtracking(List<Integer> combineList, List<List<Integer>> combinations, int start, int k, final int n){
        if(k==0){
            combinations.add(new ArrayList<>(combineList));
            return;
        }
        for(int i = start; i<=n-k+1;i++){
            combineList.add(i);
            backtracking(combineList,combinations, i+1, k-1, n);
            combineList.remove(combineList.size()-1);
        }
    }

46. 全排列

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

代码

public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();
        List<Integer> permuteList = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        backtracking(permuteList, ret, visited, nums);
        return ret;

    }
    private void backtracking(List<Integer> permuteList, List<List<Integer>> permutes, boolean[] visited, final int[] nums){
        if(permuteList.size() == nums.length) {
//            permutes.add(permuteList);
            permutes.add(new ArrayList<>(permuteList));
            return;
        }
        for(int i = 0; i<nums.length;i++){
            if(visited[i])
                continue;
            visited[i]=true;
            permuteList.add(nums[i]);
            backtracking(permuteList, permutes,visited, nums);
            permuteList.remove(permuteList.size()-1);
            visited[i]=false;
        }
    }