给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

解题思路：

回溯算法。将数字依次放入一个数组中，每加入一个数字则从剩余数字中选取一个放入数组，直到所有数字都被选取。

具体实现：

创建一个used数组，用于标记哪些数字被使用过，初始都为false。

遍历数组nums，将每个数字依次放入一个temp数组中，若temp数组长度等于nums数组长度，则将temp数组复制后加入结果数组中，退出本次递归。

若temp数组长度小于nums数组长度，则遍历nums数组，将未被使用过的数字加入temp数组，并将其标记为已使用，递归处理未使用数字的情况。处理完后将该数字标记为未使用，将其从temp数组中删除，以便继续尝试其他未使用数字。

代码实现：

相关问题

.运用c语言简单代码给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以 按任意顺序 返回答案。

这个问题可以使用回溯算法解决。回溯算法是一种通过穷举所有可能情况来找到所有解的算法。具体实现方式如下：

1. 定义一个数组visited，用于标记数字是否已经被访问过。
2. 定义一个递归函数permute，用于生成全排列。函数参数为当前要填入的位置和已经填好的部分排列。
3. 在permute函数中，如果当前位置已经填满，则将排列加入结果列表中。
4. 否则，枚举每个数字，如果该数字没有被访问过，则将其加入排列中，并标记为已访问。然后继续递归生成下一个位置的数字。
5. 递归返回时，需要将当前位置的数字从排列中移除，并取消标记为已访问。

以下是C语言的代码实现：

void permute(int* nums, int numsSize, int* visited, int* permutation, int index, int** result, int* returnSize)
{
    if (index == numsSize) {
        result[*returnSize] = malloc(numsSize * sizeof(int));
        memcpy(result[*returnSize], permutation, numsSize * sizeof(int));
        (*returnSize)++;
        return;
    }
    for (int i = 0; i < numsSize; i++) {
        if (!visited[i]) {
            visited[i] = 1;
            permutation[index] = nums[i];
            permute(nums, numsSize, visited, permutation, index + 1, result, returnSize);
            visited[i] = 0;
        }
    }
}

int** permuteUnique(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
{
    qsort(nums, numsSize, sizeof(int), cmp); // 先排序，方便去重
    int maxCount = 1;
    for (int i = 1; i <= numsSize; i++) {
        maxCount *= i;
    }
    int** result = malloc(maxCount * sizeof(int*));
    int* permutation = malloc(numsSize * sizeof(int));
    int* visited = calloc(numsSize, sizeof(int));
    *returnSize = 0;
    permute(nums, numsSize, visited, permutation, 0, result, returnSize);
    free(permutation);
    free(visited);

    // 去重
    int uniqueCount = 0;
    for (int i = 0; i < *returnSize; i++) {
        int isDuplicate = 0;
        for (int j = i + 1; j < *returnSize; j++) {
            if (memcmp(result[i], result[j], numsSize * sizeof(int)) == 0) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            result[uniqueCount++] = result[i];
        }
        else {
            free(result[i]);
        }
    }
    *returnSize = uniqueCount;

    // 设置返回结果的列数
    *returnColumnSizes = malloc(*returnSize * sizeof(int));
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = numsSize;
    }

    return result;
}

用java编写给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 示例 2： 输入：nums = [0,1] 输出：[[0,1],[1,0]] 示例 3： 输入：nums = [1] 输出：[[1]] 提示： 1 <= nums.length <= 6 -10 <= nums[i] <= 10 nums 中的所有整数 互不相同

以下是用 Java 编写的给定一个不含重复数字的数组 nums，返回其所有可能的全排列的代码：

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backtrack(res, new ArrayList<>(), nums);
        return res;
    }
    
    private void backtrack(List<List<Integer>> res, List<Integer> temp, int[] nums) {
        if (temp.size() == nums.length) {
            res.add(new ArrayList<>(temp));
        } else {
            for (int i = 0; i < nums.length; i++) {
                if (temp.contains(nums[i])) {
                    continue;
                }
                temp.add(nums[i]);
                backtrack(res, temp, nums);
                temp.remove(temp.size() - 1);
            }
        }
    }
}

这个算法的时间复杂度为 O(n!)，因为它需要生成 n! 个排列。