跟77题组合一样，在这里又遇到同样的问题，如果使用暴力解法，nums大小不同，使用的循环嵌套的层数也不同。那么这时候我们就需要使用暴力的解法。
我们看以下代码，如果nums = [1,2,3]会输出什么？

class Solution {

    List<List<Integer>> result = new ArrayList<>(); //记录最终结果
    List<Integer> path = new LinkedList<>();//记录单个组合

    public List<List<Integer>> permute(int[] nums) {
        traceBacking(nums);
        return result;
    }
    public void traceBacking(int[] nums){
        if(path.size() == nums.length)//若满足条件，终止
        {
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++){//
            path.add(nums[i]);
            traceBacking(nums);
            path.removeLast();
            }
        }
    }
}

以上代码会输出以下信息：
[[1,1,1],[1,1,2],[1,1,3],[1,2,1],[1,2,2],[1,2,3],[1,3,1],[1,3,2],[1,3,3],[2,1,1],[2,1,2],[2,1,3],[2,2,1],[2,2,2],[2,2,3],[2,3,1],[2,3,2],[2,3,3],[3,1,1],[3,1,2],[3,1,3],[3,2,1],[3,2,2],[3,2,3],[3,3,1],[3,3,2],[3,3,3]]
发现他每个元素都会重复出现，为什么会这样？

for(int i = 0; i < nums.length; i++){//
            path.add(nums[i]);
            traceBacking(nums);
            path.removeLast();
            }

因为上面这段代码在每次递归都会从nums[0]开始，所以会出现重复。
现在思考如何去重：
我们可以设置一个boolean数组，数组大小等于nums1的大小，用于记录nums中的元素有没有被使用，如果被使用，我们在选择添加元素时可以不添加，那么就不会有重复元素出现，得到的最终结果也就是全排列。于是有以下代码：

class Solution {

    List<List<Integer>> result = new ArrayList<>(); //记录最终结果
    List<Integer> path = new LinkedList<>();//记录单个组合

    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];//记录是否已经使用

        for(int i = 0; i<nums.length; i++){
            used[i] = false;
        }
        traceBacking(nums,used);
        return result;
    }
    public void traceBacking(int[] nums,boolean[] used){
        if(path.size() == nums.length)
        {
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++){
        if (!used[i]) {//如果没有使用
            path.add(nums[i]);//就添加该元素
            used[i] = true;//标记为已经使用
            traceBacking(nums,used);//递归
            used[i] = false;//记得递归返回后，该元素为未使用，因为返回了说明已经添加进结果集，那么就要进行新一轮递归了，元素当然回归未使用状态
            path.removeLast();
            }
        }
    }
}

其实在纸上模拟几遍回溯执行的过程就可以发现，他其实是在模拟嵌套循环：

 if(path.size() == nums.length)
        {
            result.add(new ArrayList<>(path));
            return;
        }

这个递归返回的条件就是循环的嵌套层数

if (!used[i]) {//如果没有使用
            path.add(nums[i]);//就添加该元素
            used[i] = true;//标记为已经使用
            traceBacking(nums,used);//递归
            used[i] = false;//记得递归返回后，该元素为未使用，因为返回了说明已经添加进结果集，那么就要进行新一轮递归了，元素当然回归未使用状态
            path.removeLast();
            }

这里就是从最内层开始遍历。