代码随想录算法训练营第18天|● 513.找树左下角的值 ● 112. 路径总和 113.路径总和ii ● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

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
}