欢迎大家参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！
## 第78题. 子集
[力扣题目链接](https://leetcode-cn.com/problems/subsets/)
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
## 思路
求子集问题和[77.组合](https://programmercarl.com/0077.组合.html)和[131.分割回文串](https://programmercarl.com/0131.分割回文串.html)又不一样了。
如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，**那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！**
其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。
**那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！**
有同学问了，什么时候for可以从0开始呢？
求排列问题的时候，就要从0开始，因为集合是有序的，{1, 2} 和{2, 1}是两个集合，排列问题我们后续的文章就会讲到的。
以示例中nums = [1,2,3]为例把求子集抽象为树型结构，如下：
从图中红线部分，可以看出**遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合**。
## 回溯三部曲
* 递归函数参数
全局变量数组path为子集收集元素，二维数组result存放子集组合。（也可以放到递归函数参数里）
递归函数参数在上面讲到了，需要startIndex。
代码如下：
```
vector> result;
vector path;
void backtracking(vector& nums, int startIndex) {
```
* 递归终止条件
从图中可以看出：
剩余集合为空的时候，就是叶子节点。
那么什么时候剩余集合为空呢？
就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了，代码如下:
```
if (startIndex >= nums.size()) {
return;
}
```
**其实可以不需要加终止条件，因为startIndex >= nums.size()，本层for循环本来也结束了**。
* 单层搜索逻辑
**求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树**。
那么单层递归逻辑代码如下：
```
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]); // 子集收集元素
backtracking(nums, i + 1); // 注意从i+1开始，元素不重复取
path.pop_back(); // 回溯
}
```
## C++代码
根据[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)给出的回溯算法模板：
```
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
```
可以写出如下回溯算法C++代码：
```CPP
class Solution {
private:
vector> result;
vector path;
void backtracking(vector& nums, int startIndex) {
result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
if (startIndex >= nums.size()) { // 终止条件可以不加
return;
}
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector> subsets(vector& nums) {
result.clear();
path.clear();
backtracking(nums, 0);
return result;
}
};
```
在注释中，可以发现可以不写终止条件，因为本来我们就要遍历整颗树。
有的同学可能担心不写终止条件会不会无限递归？
并不会，因为每次递归的下一层就是从i+1开始的。
## 总结
相信大家经过了
* 组合问题：
* [回溯算法：求组合问题](https://programmercarl.com/0077.组合.html)
* [回溯算法：组合问题再剪剪枝](https://programmercarl.com/0077.组合优化.html)
* [回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)
* [回溯算法：电话号码的字母组合](https://programmercarl.com/0017.电话号码的字母组合.html)
* [回溯算法：求组合总和（二）](https://programmercarl.com/0039.组合总和.html)
* [回溯算法：求组合总和（三）](https://programmercarl.com/0040.组合总和II.html)
* 分割问题：
* [回溯算法：分割回文串](https://programmercarl.com/0131.分割回文串.html)
* [回溯算法：复原IP地址](https://programmercarl.com/0093.复原IP地址.html)
洗礼之后，发现子集问题还真的有点简单了，其实这就是一道标准的模板题。
但是要清楚子集问题和组合问题、分割问题的的区别，**子集是收集树形结构中树的所有节点的结果**。
**而组合问题、分割问题是收集树形结构中叶子节点的结果**。
## 其他语言版本
Java：
```java
class Solution {
List> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList path = new LinkedList<>();// 用来存放符合条件结果
public List> subsets(int[] nums) {
if (nums.length == 0){
result.add(new ArrayList<>());
return result;
}
subsetsHelper(nums, 0);
return result;
}
private void subsetsHelper(int[] nums, int startIndex){
result.add(new ArrayList<>(path));//「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。
if (startIndex >= nums.length){ //终止条件可不加
return;
}
for (int i = startIndex; i < nums.length; i++){
path.add(nums[i]);
subsetsHelper(nums, i + 1);
path.removeLast();
}
}
}
```
Python：
```python3
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
res = []
path = []
def backtrack(nums,startIndex):
res.append(path[:]) #收集子集，要放在终止添加的上面，否则会漏掉自己
for i in range(startIndex,len(nums)): #当startIndex已经大于数组的长度了，就终止了，for循环本来也结束了，所以不需要终止条件
path.append(nums[i])
backtrack(nums,i+1) #递归
path.pop() #回溯
backtrack(nums,0)
return res
```
Go：
```Go
var res [][]int
func subset(nums []int) [][]int {
res = make([][]int, 0)
sort.Ints(nums)
Dfs([]int{}, nums, 0)
return res
}
func Dfs(temp, nums []int, start int){
tmp := make([]int, len(temp))
copy(tmp, temp)
res = append(res, tmp)
for i := start; i < len(nums); i++{
//if i>start&&nums[i]==nums[i-1]{
// continue
//}
temp = append(temp, nums[i])
Dfs(temp, nums, i+1)
temp = temp[:len(temp)-1]
}
}
```
Javascript:
```Javascript
var subsets = function(nums) {
let result = []
let path = []
function backtracking(startIndex) {
result.push(path.slice())
for(let i = startIndex; i < nums.length; i++) {
path.push(nums[i])
backtracking(i + 1)
path.pop()
}
}
backtracking(0)
return result
};
```
C:
```c
int* path;
int pathTop;
int** ans;
int ansTop;
//记录二维数组中每个一维数组的长度
int* length;
//将当前path数组复制到ans中
void copy() {
int* tempPath = (int*)malloc(sizeof(int) * pathTop);
int i;
for(i = 0; i < pathTop; i++) {
tempPath[i] = path[i];
}
ans = (int**)realloc(ans, sizeof(int*) * (ansTop+1));
length[ansTop] = pathTop;
ans[ansTop++] = tempPath;
}
void backTracking(int* nums, int numsSize, int startIndex) {
//收集子集，要放在终止添加的上面，否则会漏掉自己
copy();
//若startIndex大于数组大小，返回
if(startIndex >= numsSize) {
return;
}
int j;
for(j = startIndex; j < numsSize; j++) {
//将当前下标数字放入path中
path[pathTop++] = nums[j];
backTracking(nums, numsSize, j+1);
//回溯
pathTop--;
}
}
int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
//初始化辅助变量
path = (int*)malloc(sizeof(int) * numsSize);
ans = (int**)malloc(0);
length = (int*)malloc(sizeof(int) * 1500);
ansTop = pathTop = 0;
//进入回溯
backTracking(nums, numsSize, 0);
//设置二维数组中元素个数
*returnSize = ansTop;
//设置二维数组中每个一维数组的长度
*returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
int i;
for(i = 0; i < ansTop; i++) {
(*returnColumnSizes)[i] = length[i];
}
return ans;
}
```
-----------------------
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
