C 为什么我无法从下面的代码中获得二叉树级别的顺序遍历？

我正在尝试对二叉搜索树进行一次级别顺序遍历，并在多维数组中返回最终结果。例如，如果根节点是

2

并且级别1的节点是

1,4

，则它应该从代码中返回

[[2]，[1,4]]

作为

返回ColumnSizes

。我是数据结构方面的新手，也没有使用

malloc

函数的命令。任何帮助都将不胜感激。谢谢：）

int高度（结构树节点*h）{
如果（h==NULL）返回0；
int l=高度（h->左侧）；
int r=高度（h->右侧）；
如果（l>r）
返回l+1；
其他的
返回r+1；
}
int*ordercalc（结构树节点*根，int级）{
if（root==NULL）返回NULL；
int i=0，arr[100]；
如果（级别==1）
arr[i++]=root->val；
否则，如果（级别>1）{
ordercalc（root->left，level-1）；//每次调用打印数据时降低级别1
ordercalc（root->right，level-1）；//达到适当的级别
}
返回arr；
}
int**levelOrder（结构树节点*root，int*returnSize，int**returnColumnSizes）{
如果（*returnSize==0），则返回NULL；
**returnColumnSizes=（int**）malloc（*returnSize*sizeof（int*）；
对于（int i=0；i
高度
看起来不错

levelOrder
看起来不错，不过
ileft）；
int right=高度（根->右）；
返回1+（左>右？左：右）；
}
返回0；
}
空集镜头（结构树节点*根，整数*分辨率镜头，整数深度）{
如果（根）{
镜头[深度]+；
设置镜头（根->左，分辨率镜头，深度+1）；
设置镜头（根->右，分辨率镜头，深度+1）；
}
}
空洞填充级别（结构树节点*根，整数**res，整数*最后一个项目，整数级别）{
如果（根）{
int last_item=last_items[级别]++；
res[level][last_item]=root->val；
填充级别（根->左，res，最后一个项目，级别+1）；
填充级别（根->右，res，最后一个项目，级别+1）；
}
}
整数**级别顺序（结构树节点*根，整数*列，整数**列）{
如果（！root）{
*res_len=0；
返回NULL；
}
*res_len=高度（根）；
int**res=malloc（sizeof（*res）*（*res_len））；
*res_col_lens=calloc（*res_len，sizeof（**res_col_lens））；
int*last_items=calloc（*res_len，sizeof（*last_items））；
设置镜头（根，*res镜头，0）；
对于（int i=0；i<*res_len；i++）{
res[i]=malloc（sizeof（（*res）[i]）*（*res_col_lens）[i]）；
}
填充级别（根、分辨率、最后一个项目、0）；
免费（最后一项）；
返回res；
}

这样做的一个好处是将问题分解为简单、明确的步骤

我认为更自然的另一种方法是使用队列并在一个堆栈帧中执行宽度优先遍历。然后，问题就变成了用C编写一个队列抽象，这并不困难，但确实需要一些麻烦。
在ordercalc中，您设置i=0，然后arr[i++]=root->val；您不再使用
i
，因此这总是设置arr[0]=root->val，之后
i
将递增并被遗忘。
**returnColumnSizes=（int**）malloc（*returnSize*sizeof（int*）
看起来是错误的，因为
**returnColumnSizes
的类型为
int

不正确，因为返回值指向的本地数组在函数返回后不再有效。我应该如何为

**returnColumnSizes

分配内存？其余的我都明白了。我会做些改变。谢谢：）行

res[i]=malloc（sizeof（（*res）[i]）*（*res\u col\u lens）[i]）

inside for loop是如何工作的？我无法想象此处分配的内存类型。这将使用其指针解引用的大小和相应的

I

-th

res\u colu lens

值为级别

I

分配内存。我们预先计算的

sizeof（*res）

和

sizeof（*res colu lens）值是如何分配的

的工作原理是*res不是数据类型。那么，这里指的是什么大小呢？与其像

int

或

int*

那样对大小进行硬编码，不如取消对指针的引用。这样，如果类型更改，代码就不会中断。顺便说一句，如果你还没有，你可能想看看。

int height(struct TreeNode *h){
    if (h == NULL) return 0;
    int l = height(h->left);
    int r = height(h->right);
    if (l > r)
        return l+1;
    else
        return r+1;
}

int *ordercalc(struct TreeNode *root, int level){
    if (root == NULL) return NULL;
    int i = 0, arr[100];
    if (level == 1)
        arr[i++] = root->val;
    else if(level > 1){
        ordercalc(root->left, level-1);  //decrease the level one per call to print data when it
        ordercalc(root->right, level-1);  // reaches proper level
    }
    return arr;
}

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if (*returnSize == 0) return NULL;
    **returnColumnSizes = (int **)malloc(*returnSize * sizeof(int *));
    for (int i=0;i<height(root)+1;i++){
        returnColumnSizes[i] = (int *)malloc(sizeof(int) * 10);
        returnColumnSizes[i] = ordercalc(root, i);
    }
    return returnColumnSizes;
}

if (level == 1)
    arr[i++] = root->val;

return arr;

int height(struct TreeNode *root) {
    if (root) {
        int left = height(root->left);
        int right = height(root->right);
        return 1 + (left > right ? left : right);
    }

    return 0;
}

void set_col_lens(struct TreeNode *root, int *res_col_lens, int depth) {
    if (root) {
        res_col_lens[depth]++;
        set_col_lens(root->left, res_col_lens, depth + 1);
        set_col_lens(root->right, res_col_lens, depth + 1);
    }
}

void fill_levels(struct TreeNode *root, int **res, int *last_items, int level) {
    if (root) {
        int last_item = last_items[level]++;
        res[level][last_item] = root->val;
        fill_levels(root->left, res, last_items, level + 1);
        fill_levels(root->right, res, last_items, level + 1);
    }
}

int **level_order(struct TreeNode *root, int *res_len, int **res_col_lens) {
    if (!root) {
        *res_len = 0;
        return NULL;
    }

    *res_len = height(root);
    int **res = malloc(sizeof(*res) * (*res_len));
    *res_col_lens = calloc(*res_len, sizeof(**res_col_lens));
    int *last_items = calloc(*res_len, sizeof(*last_items));
    set_col_lens(root, *res_col_lens, 0);

    for (int i = 0; i < *res_len; i++) {
        res[i] = malloc(sizeof((*res)[i]) * (*res_col_lens)[i]);
    }

    fill_levels(root, res, last_items, 0);
    free(last_items);
    return res;
}