int getWeightedSum(Node* root, int depth) { if (!root) { return 0; } int sum = root->val * depth; sum += getWeightedSum(root->left, depth + 1); sum += getWeightedSum(root->right, depth + 1); return sum;}

这段代码看起来像是计算二叉树中所有节点值与其深度的乘积之和。函数名字也很明显地暗示了这一点。函数的参数包括一个树节点指针 root 和一个深度 depth。如果节点为空，函数返回 0。否则，函数先计算当前节点 root 的值乘以深度 depth，然后递归地计算左右子树的加权和。最后将这些和相加并返回。

相关问题

计算二叉排序树查找成功的平均查找长度，输出结果，用C语言来写

好的，下面是用 C 语言实现计算二叉排序树查找成功的平均查找长度的代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int val;
    struct Node *left;
    struct Node *right;
} Node;

// 插入节点
Node *insert(Node *root, int val) {
    if (!root) {
        root = (Node *)malloc(sizeof(Node));
        root->val = val;
        root->left = NULL;
        root->right = NULL;
    } else if (val < root->val) {
        root->left = insert(root->left, val);
    } else if (val > root->val) {
        root->right = insert(root->right, val);
    }
    return root;
}

// 计算节点深度之和
int sum_depth(Node *root, int depth) {
    if (!root) {
        return 0;
    }
    return depth + sum_depth(root->left, depth + 1) + sum_depth(root->right, depth + 1);
}

// 计算节点总数
int count_nodes(Node *root) {
    if (!root) {
        return 0;
    }
    return 1 + count_nodes(root->left) + count_nodes(root->right);
}

// 计算平均查找长度
float avg_search_length(Node *root) {
    int sum = sum_depth(root, 0);
    int count = count_nodes(root);
    return (float)sum / count;
}

int main() {
    // 构造一棵二叉排序树
    Node *root = NULL;
    root = insert(root, 5);
    root = insert(root, 3);
    root = insert(root, 7);
    root = insert(root, 2);
    root = insert(root, 4);
    root = insert(root, 6);
    root = insert(root, 8);

    // 计算平均查找长度并输出结果
    float avg_len = avg_search_length(root);
    printf("平均查找长度为 %.2f\n", avg_len);

    // 释放内存
    // ...
    return 0;
}

这里我构造了一棵简单的二叉排序树，并计算了它的平均查找长度。你可以根据自己的需要修改代码中的节点值来构造不同的二叉排序树。

用C语言写一个函数：该函数的功能为计算二叉树的每一层的元素的个数，并且用当前层数乘以当前层数的元素个数，将所有乘积作加法运算。

好的，下面是用C语言实现的函数代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

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

void countNodes(TreeNode* root, int level, int* sums) {
    if (root == NULL) {
        return;
    }
    sums[level]++;
    countNodes(root->left, level + 1, sums);
    countNodes(root->right, level + 1, sums);
}

int getSum(int* sums, int depth) {
    int sum = 0;
    for (int i = 1; i <= depth; i++) {
        sum += i * sums[i];
    }
    return sum;
}

int main() {
    // 构造一棵二叉树
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = 1;
    root->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->val = 2;
    root->left->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->left->val = 4;
    root->left->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->right->val = 5;
    root->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->val = 3;
    root->right->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->left->val = 6;
    root->right->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->right->val = 7;

    // 计算二叉树的深度
    int depth = maxDepth(root);

    // 统计每一层的元素个数
    int* sums = (int*)calloc(depth + 1, sizeof(int));
    countNodes(root, 1, sums);

    // 计算每层元素个数与层数的乘积的和
    int sum = getSum(sums, depth);

    // 输出结果
    printf("The sum of every level's node count times level is %d.\n", sum);

    // 释放内存
    free(sums);
    free(root->left->left);
    free(root->left->right);
    free(root->right->left);
    free(root->right->right);
    free(root->left);
    free(root->right);
    free(root);

    return 0;
}

在上面的代码中，我们先构造了一棵二叉树，然后使用`maxDepth`函数计算二叉树的深度。接着，我们使用`countNodes`函数统计二叉树每一层的元素个数，并将结果存储在`sums`数组中。最后，我们使用`getSum`函数计算每层元素个数与层数的乘积的和，并输出结果。

需要注意的是，在程序结束之前，我们需要释放二叉树占用的内存。