数据结构（C语言）回溯法与树的遍历（求子集，括号自动生成）

1.求含有N个元素的集合的子集

可参考：https://blog.csdn.net/summer_dew/article/details/83921730

求含n个元素的集合的幂集

【注释】幂集：所有子集所组成的集合
【举例】

A={1,2,3}
ρ(A) = { {1,2,3}, {1,2}, {1,3}, {1}, {2,3}, {2}, {3}, ∅ }

(数据结构C语言版 p150)

求集合A的子集，就是对A中的元素进行 取 或者 舍 的过程。

 自己写的powerset代码，空集没有做处理，用j>0的判断跳过了。

#include 
#include 
#include 
void powerSet(int ***ret,int *a,int *buf,int i,int n,int *size,int j,int *ssize){
    if(i==n){
        if(j>0){
            (*size)++;
            *ret=(int**)realloc(*ret,*size*n*sizeof(int));
            ret[0][*size-1]=(int*)malloc(j*sizeof(int));
            memcpy(ret[0][*size-1],buf,sizeof(int)*j);
            ssize[*size-1]=j;//计数，每个子集里的元素个数
            return;
        }
        else {
            return;
        }
    }
    else{
        buf[j]=a[i];
        powerSet(ret,a,buf,i+1,n,size,j+1,ssize);
        powerSet(ret,a,buf,i+1,n,size,j,ssize);
    }
}
int** generateSet(int *a,int n,int *size,int *ssize){
    int *buf=malloc(sizeof(int)*n);
    int **temp=NULL;

    powerSet(&temp,a,buf,0,n,size,0,ssize);
    return temp;
}
int main()
{
    int size=0,n=3;
    int a[]={1,2,3};
    int *ssize=malloc(100);
    int** result=generateSet(a,3,&size,ssize);
    for(int i=0;i

 

2.括号自动生成

题目链接：https://leetcode-cn.com/problems/generate-parentheses/submissions/

参考链接：https://blog.csdn.net/hang404/article/details/85063384

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
void backTrack1(char ***ret,char *before,int n,int r,int l,int *Size){
    int j=r+l;
    if(l==n)
    {

        for(;j<2*n;j++)
            before[j]=')';
        (*Size)++;
        (*ret)=(char**)realloc(*ret,(*Size)*(2*n+1)*sizeof(char *));
        (*ret)[*Size-1]=malloc(sizeof(char)*(2*n+1));
        memcpy((*ret)[*Size-1],before,2*n+1);
    }else{
        if (r==l){
            before[j]='(';
            backTrack1(ret,before,n,r,l+1,Size);
        }
        else if(l>r){
            before[j]='(';
            backTrack1(ret,before,n,r,l+1,Size);
            before[j]=')';
            backTrack1(ret,before,n,r+1,l,Size);
        }
    }
}
char** generateParenthesis(int n, int* returnSize) {
    int Size=0;
    char** result = NULL;
    char* before = (char*)malloc((n * 2 + 1) * sizeof(char));
    before[2 * n] = '\0';
    //backTrack(&result, returnSize, before, 0, n, 0);
    backTrack1(&result,before,n,0,0,&Size);
    *returnSize=Size;
    return result;
}
int main()
{
    int returnSize=0;
    char **ret=generateParenthesis(3,&returnSize);
    for(int i=0;i