leetcode102题C语言思路

最新推荐文章于 2024-07-11 23:32:17 发布

A1031091451

最新推荐文章于 2024-07-11 23:32:17 发布

阅读量1.1k

点赞数

分类专栏： leetcode 文章标签： C语言

本文链接：https://blog.csdn.net/A1031091451/article/details/79116346

版权

leetcode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

该博客介绍了如何使用C语言解决LeetCode第102题，即二叉树的层次遍历。通过`max_depth`计算树的最大深度，`calcColumnSizes`计算每一层的节点数，以及`fetch_result`获取每一层的节点值。通过递归遍历二叉树，存储不同层次的节点数量和值。

摘要由CSDN通过智能技术生成

int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) //从函数的接口分析，root为传入参数，为树的根节点。int** columnSizes, int* returnSize是传出参数，retrunSize是树的深度，columnSizes是数组，是每行的节点的个数。

因为C不能传出多个参数，因此需要保留改变值就必须参数实参，即传入地址来达到修改的目的。也可以把他们看为一个数组，相当于取出数组中的第一个元素。

首先需要得到数的深度，这个用递归很容易得到
int max_depth(struct TreeNode* root) {
    if (root == NULL) return 0;
    int ld = max_depth(root->left);
    int rd = max_depth(root->right);
    return (ld > rd ? ld : rd) + 1;
}

k为深度，对于树的遍历时，设置它可以让程序更加合理，这个技巧需要较多的联系后才能理解

然后需要遍历一遍树，找到每一层右多少个节点，这是为了给二维数组每一个位置申请空间的。
void calcColumnSizes(struct TreeNode *root, int k, int *arr) {
    if (root == NULL) return ;
    arr[k] += 1;
    calcColumnSizes(root->left, k + 1, arr);
    calcColumnSizes(root->right, k + 1, arr);
    return ;
}//也是通过递归实现的

void fetch_result(struct TreeNode *root, int k, int *ind, int **ret) {
    if (root == NULL) return ;
    ret[k][ind[k]++] = root->val;
    fetch_result(root->left, k + 1, ind, ret);
    fetch_result(root->right, k + 1, ind, ret);
    return ;
}//再次遍历一遍，记录每一层的节点


int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {
    int depth = max_depth(root);
    int *sizes = (int *)calloc(depth, sizeof(int));
    calcColumnSizes(root, 0, sizes);    
    int **ret = (int **)malloc(sizeof(int *) * depth);
    for (int i = 0; i < depth; i++) {
        ret[i] = (int *)malloc(sizeof(int) * sizes[i]);
        sizes[i] = 0;//将size设为0可以节省一个数组空间
    }
    fetch_result(root, 0, sizes, ret);
    *columnSizes = sizes;
    *returnSize = depth;
    return ret;
}

//整体实现
int max_depth(struct TreeNode* root) {
if (root == NULL) return 0;
int ld = max_depth(root->left);
int rd = max_depth(root->right);
return (ld > rd ? ld : rd) + 1;
}

void calcColumnSizes(struct TreeNode *root, int k, int *arr) {
if (root == NULL) return ;
arr[k] += 1;
calcColumnSizes(root->left, k + 1, arr);
calcColumnSizes(root->right, k + 1, arr);
return ;
}

void fetch_result(struct TreeNode *root, int k, int *ind, int **ret) {
if (root == NULL) return ;
ret[k][ind[k]++] = root->val;
fetch_result(root->left, k + 1, ind, ret);
fetch_result(root->right, k + 1, ind, ret);
return ;
}

int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {
int depth = max_depth(root);
int sizes = (int )calloc(depth, sizeof(int));
calcColumnSizes(root, 0, sizes);
int ret = (int )malloc(sizeof(int ) depth);
for (int i = 0; i < depth; i++) {
ret[i] = (int )malloc(sizeof(int) sizes[i]);
sizes[i] = 0;
}
fetch_result(root, 0, sizes, ret);
*columnSizes = sizes;
*returnSize = depth;
return ret;
}
“`