513.找树左下角的值
题目描述:
给定一个二叉树的 根节点
root
,请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。
示例 1:
输入: root = [2,1,3] 输出: 1示例 2:
输入: [1,2,3,4,null,5,6,null,null,7] 输出: 7提示:
- 二叉树的节点个数的范围是
[1,104]
-231 <= Node.val <= 231 - 1
思路:
找到深度最大的叶子节点,注意,该节点不一定是左节点,因为我们要求的是最后一行最左侧的值,只需要找到最大的深度就可以,并且这里使用前中后序遍历都可以实现,因此优先都会遍历左节点才到右节点
实现:
1.定义一个全局变量,用来记录二叉树的最大深度,并初始化为一个不可能到达的最小值,再定义一个变量,记录深度最大的值
2.实现递归的三部曲
2.1确定递归函数的参数和返回值,这里返回值应该为空,应该传入根节点和当前最大深度
2.2确定终止条件,即遍历到叶子节点,判断当前深度与最大深度,如果当前深度大于最大的深度,则更新最大深度的值
2.3确定单层递归的逻辑,左右遍历,注意回溯的过程
代码:
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ //记录二叉树的最大深度 int max = -10; //记录最大深度的值 int cur; //depth遍历当前深度 void rec(struct TreeNode *root, int depth) { if(root == NULL) return ; if(root->left == NULL && root->right == NULL) { //找到最大深度 if(depth > max) { max = depth; cur = root->val; } } //向左遍历,有回溯 if(root->left) { rec(root->left,depth+1); } //向右遍历,有回溯 if(root->right) { rec(root->right,depth+1); } return ; } int findBottomLeftValue(struct TreeNode* root) { max = -10; rec(root,0); return cur; }
112.路径总和
题目描述:
给你二叉树的根节点
root
和一个表示目标和的整数targetSum
。判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和targetSum
。如果存在,返回true
;否则,返回false
。叶子节点 是指没有子节点的节点。
示例 1:
输入:root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出:true 解释:等于目标和的根节点到叶节点路径如上图所示。示例 2:
输入:root = [1,2,3], targetSum = 5 输出:false 解释:树中存在两条根节点到叶子节点的路径: (1 --> 2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。示例 3:
输入:root = [], targetSum = 0 输出:false 解释:由于树是空的,所以不存在根节点到叶子节点的路径。提示:
- 树中节点的数目在范围
[0, 5000]
内-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000
思路:
查找到某一条符合条件的路径,就可以直接返回,实现思路是我们遍历二叉树,当遍历到一个节点,就让该目标值减去叶子节点的值,如果到达叶子节点,且我们的目标值为0,则代表查找到了符合条件的路径
使用递归函数实现
1.确定函数的参数和返回值,要求返回真和假,因此返回值为bool类型,参数为要传入的根节点和要计算的数
2.确定函数终止条件,如果遇到叶子节点,其目标值为0,则返回真,如果已经到叶子节点,但是目标值不是0,则代表这条路径不是我们想要的路径,返回假
3.确定单层递归逻辑,向左递归(注意判断该节点,防止操作空指针),注意递归函数的返回值,如果返回值为真,代表左方向有符合条件的路径,则继续向上返回,注意回退的过程,向右递归也是一样的过程
使用前中后序遍历都可以,因为不涉及到中结点的处理逻辑
代码:
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ bool hasPathSum(struct TreeNode* root, int targetSum) { if(!root) return false; if(!root->left && !root->right && targetSum == root->val) return true; return hasPathSum(root->left,targetSum-root->val) || hasPathSum(root->right,targetSum-root->val); }
106.从中序和后序遍历序列构造二叉树
题目描述:
给定两个整数数组
inorder
和postorder
,其中inorder
是二叉树的中序遍历,postorder
是同一棵树的后序遍历,请你构造并返回这颗 二叉树 。示例 1:
输入:inorder = [9,3,15,20,7], postorder = [9,15,7,20,3] 输出:[3,9,20,null,null,15,7]示例 2:
输入:inorder = [-1], postorder = [-1] 输出:[-1]提示:
1 <= inorder.length <= 3000
postorder.length == inorder.length
-3000 <= inorder[i], postorder[i] <= 3000
inorder
和postorder
都由 不同 的值组成postorder
中每一个值都在inorder
中inorder
保证是树的中序遍历postorder
保证是树的后序遍历
思路:
中序:左中右
后序,左右中
由后序遍历的结果就可以知道数组的最后一个元素就是根节点,根据根节点和中序遍历,就可以分辨出根节点的左右子树,根据左右子树又可以结合后序遍历的结果,就可以进行构建
代码实现:
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ int search(int *inorder, int inorderSize, int num) { int i; for(i = 0; i < inorderSize; i++) if(inorder[i] == num) return i; return -1; } struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize) { if (postorderSize == 0) // 如果后序遍历数组为空,则返回 NULL return NULL; struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode)); node->val = postorder[postorderSize - 1]; int lindex = search(inorder, inorderSize, node->val); // 找到根节点在中序遍历中的位置 // 计算左右子树的大小 int leftSize = lindex; int rightSize = inorder - lindex -1; // 递归构建左右子树 node->left = buildTree(inorder, leftSize, postorder, leftSize); node->right = buildTree(inorder + lindex + 1, rightSize, postorder + leftSize, rightSize); return node; }
105.从前序与中序遍历序列构造二叉树
题目描述:
给定两个整数数组
preorder
和inorder
,其中preorder
是二叉树的先序遍历,inorder
是同一棵树的中序遍历,请构造二叉树并返回其根节点。示例 1:
输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] 输出: [3,9,20,null,null,15,7]示例 2:
输入: preorder = [-1], inorder = [-1] 输出: [-1]提示:
1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder
和inorder
均 无重复 元素inorder
均出现在preorder
preorder
保证 为二叉树的前序遍历序列inorder
保证 为二叉树的中序遍历序列
思路:
中序的顺序:左中右
也是按照分割的思想,找出两个数组中左右子树的位置
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize) { // 检查前序遍历数组是否为空,如果为空,则返回空指针 if(preorder == NULL || preorderSize == 0) return NULL; // 分配内存空间以存储新的树节点,并设置节点的值为前序遍历数组的第一个元素 struct TreeNode *node = (struct TreeNode *)malloc(sizeof(struct TreeNode)); node->val = preorder[0]; node->left = NULL; node->right = NULL; // 如果前序遍历数组只有一个元素,直接返回该节点 if(preorderSize == 1) return node; // 计算左子树在中序遍历中的元素个数 int lsize; for(lsize = 0; lsize < inorderSize ; lsize++) { if(inorder[lsize] == preorder[0]) break; } // 计算右子树在中序遍历中的元素个数 int rsize = inorderSize - lsize - 1; // 定义左子树和右子树的中序遍历数组指针 int *leftO = inorder; int *rightO = inorder + lsize + 1; // 定义左子树和右子树的前序遍历数组指针 int *leftp = preorder + 1; int *rightp = preorder + lsize + 1; // 递归构建左子树 node->left = buildTree(leftp, lsize, leftO, lsize); // 递归构建右子树 node->right = buildTree(rightp , rsize, rightO, rsize); // 返回当前节点 return node; }