前提：沒有重複數字的序列

解法一：

List<List<Integer>> result = new ArrayList<>();
public List<List<Integer>> permute(int[] nums) {
    boolean[] map = new boolean[nums.length];
    dfs(nums, map, new ArrayList<>());
    return result;
}
public void dfs(int[] nums, boolean[] visited,
 
 List<Integer> tmp) {
    if (tmp.size() == nums.length)
        result.add(new ArrayList<>(tmp));
    else {
        // 否則，開始迴圈遍歷，按照0,1,2..的順序依次選擇起點，然後遍歷
        for (int i = 0; i < nums.length; i++) {
            if (visited[i])// 若該點已經被訪問過了，則跳過訪問下一個點
                continue;
            else
 
 {
            	// 若沒被訪問過，那麼先標記為訪問了，然後將其加入 tmp 中，
            	//等得到一個全排列的結果時加入到 result 中
                visited[i] = true;
                tmp.add(nums[i]);
                dfs(nums, visited, tmp);// 遞迴呼叫
                // 遞迴結束，還原當前位置的狀態（即回溯），使得可以填充下一個元素，
                // 從而進行新的組合
                tmp.remove
 
(tmp.size() - 1);
                // 訪問標記還原，使得下次遍歷還可以使用該元素
                visited[i] = false;
            }
        }
    }
}

例如：對於 [1，2，3]，有如下部分過程示例

dfs(mums, visited, tmp())
	i = 0: v[0] = true
		  tmp = (1)
	      dfs(mums, visited, tmp(1))
		      i = 0: continue
			  i = 1: v[1] = true
	  		  tmp = (1, 2)
			  dfs(mums, visited, tmp(1, 2))
				  i = 0: continue
		  		  i = 1: continue
				  i = 2: v[2] = true
						 tmp = (1, 2, 3)
						 dfs(mums, visited, tmp(1, 2, 3))
					         add to result list
						 after tmp.remove(3 -1) tmp = (1, 2) 
						 v[2] = false
                  loop end
			  // 遞迴結束，還原 tmp[1]，去掉 tmp(1, 2) 的第二個元素
			  // 即回溯，得到 tmp = (1)，使得 tmp[1] 位置可以填充下一個元素
              after tmp.remove(2 -1) tmp = (1)  
			  v[1] = false 
	          i = 2: v[2] = true
			  ...

解法二：

交換解法，核心部分就是將各個位都與後面的每一個位都交換一次，並且這種交換是累積式的

public List<List<Integer>> permute(int[] nums) {
    helper(nums, 0);
    return result;
}

public void helper(int[] nums, int i){
    // 找到轉置完成後的解，將其存入列表中
    if(i == nums.length - 1){
        List<Integer> list = new LinkedList<Integer
        for(int j = 0; j < nums.length; j++){
            list.add(nums[j]);
        }
        result.add(list);
    }
    // 將當前位置的數跟後面的數交換，並搜尋解
    for(int j = i; j < nums.length; j++){
        swap(nums, i, j);// 交換位置
        helper(nums, i + 1);
        swap(nums, i, j);// 還原前面交換的位置
    }
}

private void swap(int[] nums, int i, int j){
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}