给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。java

以下是Java代码实现：

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), nums, 0);
        return result;
    }
    
    private void backtrack(List<List<Integer>> result, List<Integer> subset, int[] nums, int start) {
        result.add(new ArrayList<>(subset));
        for (int i = start; i < nums.length; i++) {
            subset.add(nums[i]);
            backtrack(result, subset, nums, i + 1);
            subset.remove(subset.size() - 1);
        }
    }
}

使用回溯法来生成所有子集。我们从空集开始，每次将一个数字加入当前集合中，再递归生成子集，直到遍历完所有数字。在递归返回时，将最后一个数字从集合中移除，回溯到上一层。最终得到的所有集合即为所有子集。

相关问题

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

对于给定的整数数组nums，求它的所有子集（幂集）的问题，可以使用递归的方法来解决。

首先，我们考虑数组nums的长度为0的情况。在这种情况下，数组nums的所有子集都是空集，所以我们可以直接返回空集。

接下来，我们考虑数组nums的长度为1的情况。在这种情况下，数组nums的所有子集包括空集和数组nums本身，即[], [nums[0]]。

最后，我们考虑数组nums的长度大于1的情况。在这种情况下，我们可以将数组nums分成两部分，分别为nums[0:len(nums)-1]和nums[len(nums)-1]。对于nums[0:len(nums)-1]，我们可以递归地求出它的所有子集，然后将nums[len(nums)-1]加入到每一个子集中。这样就可以得到数组nums的所有子集。

示例代码如下：

def subsets(nums):
    if not nums:
        return [[]]
    if len(nums) == 1:
        return [[], nums]
    res = []
    for subset in subsets(nums[:-1]):
        res.append(subset)
        res.append(subset + [nums[-1]])
    return res

这里假设我们使用 Python 语言来实现。

C语言实现整数数组 `nums` ，数组中的元素 **互不相同** 。返回该数组所有可能的子集（幂集）。解集 **不能** 包含重复的子集，可以按 **任意顺序** 返回解集

要实现返回整数数组 `nums` 的所有可能子集（幂集），可以使用回溯法来解决。回溯法是一种通过递归和回溯搜索所有解空间的方法。下面是使用C语言编写的示例代码：

#include <stdio.h>
#include <stdlib.h>

void backtrack(int* nums, int numsSize, int* subset, int subsetSize, int start, int** result, int* returnSize, int** returnColumnSizes) {
    // 将当前子集添加到结果数组
    result[*returnSize] = (int*) malloc(subsetSize * sizeof(int));
    memcpy(result[*returnSize], subset, subsetSize * sizeof(int));
    (*returnColumnSizes)[*returnSize] = subsetSize;
    (*returnSize)++;
    
    for (int i = start; i < numsSize; i++) {
        // 将当前元素添加到子集中
        subset[subsetSize] = nums[i];
        subsetSize++;
        
        // 继续向下搜索
        backtrack(nums, numsSize, subset, subsetSize, i + 1, result, returnSize, returnColumnSizes);
        
        // 回溯，将当前元素从子集中移除
        subsetSize--;
    }
}

int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    // 计算幂集的大小
    int numSubsets = 1 << numsSize;
    *returnSize = 0;
    
    // 分配结果数组和列大小数组的空间
    int** result = (int**) malloc(numSubsets * sizeof(int*));
    *returnColumnSizes = (int*) malloc(numSubsets * sizeof(int));
    
    // 分配临时子集数组的空间
    int* subset = (int*) malloc(numsSize * sizeof(int));
    
    // 使用回溯法搜索所有子集
    backtrack(nums, numsSize, subset, 0, 0, result, returnSize, returnColumnSizes);
    
    // 释放临时子集数组的空间
    free(subset);
    
    return result;
}

void freeSubsets(int** subsets, int numSubsets, int* returnColumnSizes) {
    for (int i = 0; i < numSubsets; i++) {
        free(subsets[i]);
    }
    free(subsets);
    free(returnColumnSizes);
}

int main() {
    int nums[] = {1, 2, 3};
    int numsSize = sizeof(nums) / sizeof(nums[0]);
    
    int returnSize;
    int* returnColumnSizes;
    
    int** result = subsets(nums, numsSize, &returnSize, &returnColumnSizes);
    
    // 输出所有子集
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d ", result[i][j]);
        }
        printf("]\n");
    }
    
    // 释放内存
    freeSubsets(result, returnSize, returnColumnSizes);
    
    return 0;
}

在这个示例代码中，我们首先定义了 `backtrack` 函数，它用于回溯搜索所有可能的子集。它接受当前数组 `nums`、数组大小 `numsSize`、当前子集 `subset`、子集大小 `subsetSize`、起始索引 `start`、结果数组 `result`、结果数组大小 `returnSize` 和结果数组列大小 `returnColumnSizes`。在每个递归步骤中，我们将当前子集添加到结果数组，然后继续向下递归搜索。在回溯时，我们将当前元素从子集中移除。

然后，我们定义了 `subsets` 函数，它接受整数数组 `nums`、数组大小 `numsSize`、返回子集的数量 `returnSize` 和返回每个子集的大小 `returnColumnSizes`。该函数使用回溯法搜索所有可能的子集，并将它们存储在一个二维数组中。

最后，在 `main` 函数中，我们使用示例数组 `[1, 2, 3]` 调用 `subsets` 函数，并输出所有生成的子集。最后，我们使用 `freeSubsets` 函数释放分配的内存。

请注意，在使用完动态分配的内存后，一定要记得使用 `free` 函数将其释放，以避免内存泄漏的问题。