递归和回溯两种方法解决全排列问题

    public List<List<Integer>> permute(int[] nums) {
        return permuteMain(nums, nums.length);
    }

    // 采用递归，自顶而下
    private List<List<Integer>> permuteMain(int[] nums, int len) {
        if(len == 0){
            return new ArrayList<List<Integer>>();
        }
        List<List<Integer>> result = new ArrayList<>();
        List<List<Integer>> pre = permuteMain(nums, len - 1);
        if(pre.size() == 0){
            result.add(new ArrayList<Integer>(){{
                add(nums[len - 1]);
            }});
            return result;
        }
        for (List<Integer> list : pre) {
            for(int i = 0; i <= list.size(); i++){
                List<Integer> tempList = new ArrayList<>(list);
                tempList.add(i, nums[len - 1]);
                result.add(tempList);
            }
        }

        return result;
    }

    // 采用回溯

    private List<List<Integer>> result = new LinkedList<>();

    private List<List<Integer>> permute2(int[] nums) {
        // 记录轨迹
        LinkedList<Integer> trace = new LinkedList<>();
        backtrace(nums, trace);
        return result;
    }

    // 回溯函数
    private void backtrace(int[] nums, LinkedList<Integer> trace) {
        // trace为全排列路径
        if(nums.length == trace.size()){
            result.add(new LinkedList<>(trace));
            return;
        }

        for(int i = 0; i < nums.length; i++){
            // 做出选择，选择不能为自身
            if(trace.contains(nums[i])){
                continue;
            }
            // 回溯前添加元素
            trace.add(nums[i]);
            backtrace(nums, trace);
            // 回溯后撤销操作
            trace.removeLast();
        }
    }