leetcode重点分类(C语言) - 分治

 分类参考：https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E7%9B%AE%E5%BD%95.md

 

241. 为运算表达式设计优先级

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int* diffWaysToCompute(char * input, int* returnSize)
{
    if(!input) {
        *returnSize = 0;
        return NULL;
    }
    int len = strlen(input);
    int* ret = (int*)malloc(sizeof(int));
    int mid = 0, cnt = 0, flag = 0, lsize = 0, rsize = 0;
    //mid:运算符;cnt:总元素个数计数;flag:是否经过循环（由于左右字串递归，只能由此判断是否字串只有一个元素）;lsize,rsize:mid左右元素个数
    char* lstr=(char*)malloc(len * sizeof(char));
    char* rstr=(char*)malloc(len * sizeof(char));
    while(mid < len) {
        if(input[mid] >= '0' && input[mid] <= '9') {
            mid++;
            continue;
        }
        flag = 1;
        memcpy(lstr, input, mid);
        lstr[mid] = '\0';
        memcpy(rstr, input+mid+1, len-mid-1);
        rstr[len-mid-1] = '\0';
        int* lret = diffWaysToCompute(lstr, &lsize);
        int* rret = diffWaysToCompute(rstr, &rsize);
        int* tmp = (int*)realloc(ret, (cnt + lsize * rsize) * sizeof(int));
        ret = tmp;
        for(int i = 0; i < lsize; i++) {
            for(int j = 0; j < rsize; j++) {
                switch(input[mid]){
                    case '+':
                        ret[cnt++] = lret[i] + rret[j];
                        break;
                    case '-':
                        ret[cnt++] = lret[i] - rret[j];
                        break;
                    case '*':
                        ret[cnt++] = lret[i] * rret[j];
                        break;
                    default:
                        break;
                }
            }
        }
        mid++;       
    }  
    if(flag == 0) {
        *returnSize = 1;
        ret[0] = atoi(input);
        return ret;
    }
    *returnSize = cnt;
    return ret;
}

 

95. 不同的二叉搜索树 II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

struct TreeNode** create(int start, int end, int* m)
{
    struct TreeNode **p, **lefts, **rights;
    int a, i, b, j, k, count = 0;
    if(start > end) {
        p = (struct TreeNode**)malloc(sizeof(struct TreeNode*));
        *p = NULL;
        *m = 1;
        return p;
    } 
    if(start == end) {
        p = (struct TreeNode**)malloc(sizeof(struct TreeNode*));
        *p = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        (*p)->left = (*p)->right = NULL;   //当子树为1时的赋值
        (*p)->val = start;
        *m = 1;
        return p;
    }
    p=(struct TreeNode**)malloc(sizeof(struct TreeNode*) * 10000);
    for(i = start; i <= end; i++) {
        lefts = create(start, i - 1, &a);
        rights = create(i + 1, end, &b);
        for(k = 0; k < a; k++) {
            for(j = 0; j < b; j++) {
                p[count] = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                p[count]->val = i;
                p[count]->left = lefts[k];
                p[count]->right = rights[j];      
                count++;
            }
        } 
    }
    *m = count;
    return p;
}

struct TreeNode** generateTrees(int n, int* returnSize)
{
    struct TreeNode** p;
    if(n == 0) {
        *returnSize = 0;
        return NULL;
    }
    p = create(1, n, returnSize);
    return p;
}