四种语言刷算法之子集

力扣78. 子集

1、C

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
void backtracing(int *nums,int numsSize,int start,int *returnSize,int ** returnColumnSizes,int *path,int *pathSize,int **result){
    result[*returnSize] = (int *)malloc(sizeof(int)*numsSize);
    memcpy(result[*returnSize], path, sizeof(int) * numsSize);
    (*returnColumnSizes)[*returnSize] = *pathSize;
    (*returnSize)++;
    for(int i=start;i<numsSize;i++){
        path[*pathSize] = nums[i];
        (*pathSize)++;
        backtracing(nums,numsSize,i+1,returnSize,returnColumnSizes,path,pathSize,result);
       (*pathSize)--;
    }
}

int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    *returnSize = 0;
    int *path = (int *)malloc(sizeof(int)*numsSize);
    int ** result = (int **)malloc(sizeof(int*)*100001);
    *returnColumnSizes = (int *)malloc(sizeof(int)*100001);
    int *pathSize = (int *)calloc(1,sizeof(int));
    backtracing(nums,numsSize,0,returnSize,returnColumnSizes,path,pathSize,result);
    return result;
}

2、C++

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracing(vector<int> &nums,int start){
        result.push_back(path);
        for(int i=start;i<nums.size();i++){
            path.push_back(nums[i]);
            backtracing(nums,i+1);
            path.pop_back();
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        backtracing(nums,0);
        return result;
    }
};

3、JAVA

class Solution {
    LinkedList<Integer> path = new LinkedList<Integer>();
    List<List<Integer>> result = new ArrayList<>();
    
    void backtracking(int[] nums,int start){
        result.add(new ArrayList(path));
        for(int i=start;i<nums.length;i++){
            path.addLast(nums[i]);
            backtracking(nums,i+1);
            path.removeLast();
        }
    }

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

4、Python

class Solution(object):

    def __init__(self):
        self.path = []
        self.result = []

    def backtracing(self,nums,start):
        self.result.append(self.path[:])
        for i in range(start,len(nums)):
            self.path.append(nums[i])
            self.backtracing(nums,i+1)
            self.path.remove(nums[i])

    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.backtracing(nums,0)
        return self.result