二叉树基本概念及代码

对于二叉树，

像计算机比赛什么的，

都是很常考的，

就让我来科普一下吧：

二叉树路径指从树根节点开始到叶子节点的路径，

可以经过多个节点。

在二叉树中，

路径可以通过遍历算法来遍历树中的节点。

一般来说，

我们可以使用深度优先搜索（DFS）来查找二叉树中的路径。

DFS算法的基本思想是递归地访问树的每个节点，

并保存路径信息。

当访问到叶子节点时，

将路径信息加入到结果中。

在二叉树中，

路径可以从树的任意节点开始，

并且可以不经过根节点。

因此，

我们可以使用一个递归函数来遍历每个节点，

并保存从该节点开始的路径信息。

具体代码如下：

// 定义二叉树结构体
typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;
 
// 定义保存路径的动态数组
typedef struct {
    int* data;
    int size;
    int capacity;
} Path;
 
Path* createPath(int capacity) {
    Path* p = (Path*)malloc(sizeof(Path));
    p->data = (int*)malloc(sizeof(int) * capacity);
    p->size = 0;
    p->capacity = capacity;
    return p;
}
 
void destroyPath(Path* p) {
    free(p->data);
    free(p);
}
 
void dfs(TreeNode* root, Path* path, int sum, int targetSum, int* returnSize, int** returnColumnSizes, int** result) {
    if (root == NULL) {
        return;
    }
 
    // 将当前节点加入到路径中
    path->data[path->size++] = root->val;
    sum += root->val;
 
    // 判断是否到达叶子节点，如果是则将路径信息加入到结果中
    if (root->left == NULL && root->right == NULL) {
        if (sum == targetSum) {
            result[*returnSize] = (int*)malloc(sizeof(int) * path->size);
            memcpy(result[*returnSize], path->data, sizeof(int) * path->size);
            (*returnColumnSizes)[*returnSize] = path->size;
            (*returnSize)++;
        }
    } else {
        // 递归访问左右子树
        dfs(root->left, path, sum, targetSum, returnSize, returnColumnSizes, result);
        dfs(root->right, path, sum, targetSum, returnSize, returnColumnSizes, result);
    }
 
    // 将当前节点从路径中删除
    path->size--;
    sum -= root->val;
}
 
int** binaryTreePathSum(TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes) {
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }
 
    // 初始化结果集
    int capacity = 1000;
    int** result = (int**)malloc(sizeof(int*) * capacity);
    *returnColumnSizes = (int*)malloc(sizeof(int) * capacity);
    *returnSize = 0;
 
    // 创建保存路径的动态数组
    Path* path = createPath(capacity);
 
    // 计算所有的路径
    dfs(root, path, 0, targetSum, returnSize, returnColumnSizes, result);
 
    // 销毁保存路径的动态数组
    destroyPath(path);
 
    // 返回结果集
    return result;
}

在上面的代码中，

我们通过深度优先搜索遍历了二叉树，

并保存了从根节点到叶子节点的路径信息。

然后，

我们计算了所有节点之和为目标值的路径，

并将它们添加到结果集中。

总之，

通过深度优先搜索算法，

我们可以计算出二叉树中所有的路径，

并找出其中所有节点之和为目标值的路径。

好了，

以上就是今天的所有内容

因为最近修勾上课都在考

所以

【咳嗽】

为了不让粉丝们头疼

我才做了这期文章

我是修勾

记得每天保持微笑

我们下期不见不散。