513. 找树左下角的值
中等
给定一个二叉树的 根节点 root,请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
示例 1:
[图片]
输入: root = [2,1,3]
输出: 1
示例 2:
[图片]
输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7
代码
func findBottomLeftValue(root *TreeNode) int {
//层次排序
queue := make([]*TreeNode, 0)
queue = append(queue, root)
result := 0
for len(queue) > 0 {
next := make([]*TreeNode, 0)
for i := 0; i < len(queue); i++ {
x := queue[i]
if x != nil {
if x.Left != nil {
next = append(next, x.Left)
}
if x.Right != nil {
next = append(next, x.Right)
}
}
}
if len(queue) > 0 {
result = queue[0].Val
}
queue = next
}
return result
}
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
代码
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func hasPathSum(root *TreeNode, targetSum int) bool {
if root == nil {
return false
}
// 将targetSum在遍历每层的时候都减去本层节点的值
targetSum -= root.Val
// 如果剩余的targetSum为0, 则正好就是符合的结果
if root.Left == nil && root.Right == nil && targetSum == 0 {
return true
}
return hasPathSum(root.Left, targetSum) || hasPathSum(root.Right, targetSum) // 否则递归找
}
func hasPathSum(root *TreeNode, targetSum int) bool {
result := make([]int, 0) //记录数组
dfs_hPS(root, &result,0)
for _, i:=range result{
if i==targetSum{
return true
}
}
return false
}
func dfs_hPS(root *TreeNode, nums *[]int, num int) {
if root == nil {
return
}
num += root.Val
if root.Left == nil && root.Right == nil {
*nums = append(*nums, num)
}
dfs_hPS(root.Left, nums, num)
dfs_hPS(root.Right, nums, num)
return
}
113. 路径总和 II
中等
给你二叉树的根节点 root 和一个整数目标和 targetSum ,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
示例 2:
[图片]
输入:root = [1,2,3], targetSum = 5
输出:[]
示例 3:
输入:root = [1,2], targetSum = 0
输出:[]
提示:
- 树中节点总数在范围 [0, 5000] 内
- -1000 <= Node.val <= 1000
- -1000 <= targetSum <= 1000
思路: - traverse(root, &result, new([]int), targetSum)
- &数组取地址
- 路径要有增有删
代码
func pathSum(root *TreeNode, targetSum int) [][]int {
nums := make([]int, 0)
trace := make([][]int, 0)
result := make([][]int, 0)
dfs_hPSii(root, nums, &trace)
for i := range trace {
sum := 0
for j := range trace[i] {
sum += trace[i][j]
}
if sum == targetSum {
result = append(result, trace[i])
}
}
return result
}
func dfs_hPSii(root *TreeNode, nums []int, trace *[][]int) {
if root == nil {
return
}
// 复制 nums
path := append([]int{}, nums...) //path 是在每次递归调用中新创建的切片,确保每个路径有独立的存储空间,不受其他路径的影响。
path = append(path, root.Val)
if root.Left == nil && root.Right == nil {
*trace = append(*trace, path)
}
dfs_hPSii(root.Left, path, trace)
dfs_hPSii(root.Right, path, trace)
return
}
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 保证是树的后序遍历
思路
- 第一步:如果数组大小为零的话,说明是空节点了。
- 第二步:如果不为空,那么取后序数组最后一个元素作为节点元素。
- 第三步:找到后序数组最后一个元素在中序数组的位置,作为切割点
- 第四步:切割中序数组,切成中序左数组和中序右数组 (顺序别搞反了,一定是先切中序数组)
- 第五步:切割后序数组,切成后序左数组和后序右数组
- 第六步:递归处理左区间和右区间
代码
package __tree
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func buildTree(inorder []int, postorder []int) *TreeNode {
// 第一步
if len(inorder) == 0 {
return nil
}
// 第二步:后序遍历数组最后一个元素,就是当前的中间节点
rootValue := postorder[len(postorder)-1]
root := TreeNode{rootValue, nil, nil}
// 第三步:找切割点
x := postorder[len(postorder)-1]
index := 0
for i, in := range inorder {
if in == x {
index = i
}
}
// postorder 舍弃末尾元素,因为这个元素就是中间节点,已经用过了
postorder = postorder[:len(postorder)-1]
// 第四步:切割中序数组,得到 中序左数组和中序右数组
// 第五步:切割后序数组,得到 后序左数组和后序右数组
root.Left = buildTree(inorder[:index], postorder[:index])
root.Right = buildTree(inorder[index+1:], postorder[index:])
return &root
}
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.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func buildTree(preorder []int, inorder []int) *TreeNode {
if len(preorder)==0{
return nil
}
x:=preorder[0]
preorder = preorder[1:]
index:=0
for i,in :=range inorder{
if in==x{
index=i
}
}
root:=TreeNode{x,nil,nil}
root.Left = buildTree(preorder[:index],inorder[:index])
root.Right = buildTree(preorder[index:],inorder[index+1:])
return &root
}