自己解法

这个题的思路比较简单，就是经典的回溯法，但是写起来并没有那么的得心应手，主要是对于还可以使用的元素的处理不是特别清晰，最开始是可使用元素也用了回溯的操作，这样发现循环里面会存在增加元素，而继续进行的情况，把这个地方改成每次新维护数组以后就可以了。

class Solution {

    List<List<Integer>> output = new ArrayList<>(16);

    List<Integer> res = new ArrayList<>(16);

    int count;

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

        if (nums.length == 0) {

            return output;                 

        }

        count = nums.length;

        List<Integer> remainNums = Arrays.stream(nums)

                        .boxed()

                        .collect(Collectors.toList());

        dfs(remainNums);

        return output;

    }

    public void dfs(List<Integer> remainNums) {

        if (res.size() == count) {

            output.add(new ArrayList<Integer>(res)); 

            return;            

        }

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

            int a = remainNums.get(i);

            List<Integer> remainList = new ArrayList<Integer>(remainNums);

            res.add(a);

            remainList.remove(i);

            dfs(remainList);

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

        }

    } 

}

官方解法

首先解法思路都是一样的，这种是用了个boolean[] used来维护哪些下标是已经访问过的，在回溯的过程中,置used[i]为false，来重置，这样处理整体更协调一些。

import java.util.ArrayList;

import java.util.List;

public class Solution {

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

        // 首先是特判

        int len = nums.length;

        // 使用一个动态数组保存所有可能的全排列

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

        if (len == 0) {

            return res;

        }

        boolean[] used = new boolean[len];

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

        dfs(nums, len, 0, path, used, res);

        return res;

    }

    private void dfs(int[] nums, int len, int depth,

                    List<Integer> path, boolean[] used,

                    List<List<Integer>> res) {

        if (depth == len) {

            res.add(new ArrayList<Integer>(path));

            return;

        }

        for (int i = 0; i < len; i++) {

            if (!used[i]) {

                path.add(nums[i]);

                used[i] = true;

                dfs(nums, len, depth + 1, path, used, res);

                // 注意：这里是状态重置，是从深层结点回到浅层结点的过程，代码在形式上和递归之前是对称的

                used[i] = false;

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

            }

        }

    }

    public static void main(String[] args) {

        int[] nums = {1, 2, 3};

        Solution solution = new Solution();

        List<List<Integer>> lists = solution.permute(nums);

        System.out.println(lists);

    }

}