Golang每日一练(leetDay0091) 二叉树的所有路径、各位相加

简介: Golang每日一练(leetDay0091) 二叉树的所有路径、各位相加

257. 二叉树的所有路径 Binary-tree Paths

给你一个二叉树的根节点 root ,按 任意顺序 ,返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

示例 1:

输入:root = [1,2,3,null,5]

输出:["1->2->5","1->3"]


示例 2:

输入:root = [1]

输出:["1"]


提示:

  • 树中节点的数目在范围 [1, 100]
  • -100 <= Node.val <= 100

代码1:

遍历出所有路径,再改写字符串数组。参见:

Golang每日一练(leetDay0038) 二叉树专题(7)路径总和I\II

package main
import (
  "fmt"
)
const null = -1 << 31
type TreeNode struct {
  Val   int
  Left  *TreeNode
  Right *TreeNode
}
func binaryTreePaths(root *TreeNode) []string {
  res := []string{}
  paths := PathsLists(root)
  if len(paths) == 0 {
    return res
  }
  for _, path := range paths {
    res = append(res, getPath(path))
  }
  return res
}
func getPath(path []int) string {
  var res string
  for i := 0; i < len(path)-1; i++ {
    res += fmt.Sprintf("%d", path[i]) + "->"
  }
  res += fmt.Sprintf("%d", path[len(path)-1])
  return res
}
func PathsLists(root *TreeNode) [][]int {
  res := [][]int{}
  if root == nil {
    return res
  }
  if root.Left == nil && root.Right == nil {
    return [][]int{{root.Val}}
  }
  leftPaths := PathsLists(root.Left)
  rightPaths := PathsLists(root.Right)
  paths := make([][]int, 0)
  for _, path := range leftPaths {
    paths = append(paths, append([]int{root.Val}, path...))
  }
  for _, path := range rightPaths {
    paths = append(paths, append([]int{root.Val}, path...))
  }
  return paths
}
func buildTree(nums []int) *TreeNode {
  if len(nums) == 0 {
    return nil
  }
  root := &TreeNode{Val: nums[0]}
  Queue := []*TreeNode{root}
  idx := 1
  for idx < len(nums) {
    node := Queue[0]
    Queue = Queue[1:]
    if nums[idx] != null {
      node.Left = &TreeNode{Val: nums[idx]}
      Queue = append(Queue, node.Left)
    }
    idx++
    if idx < len(nums) && nums[idx] != null {
      node.Right = &TreeNode{Val: nums[idx]}
      Queue = append(Queue, node.Right)
    }
    idx++
  }
  return root
}
func main() {
  nums := []int{1, 2, 3, null, 5}
  root := buildTree(nums)
  fmt.Println(binaryTreePaths(root))
  nums = []int{1}
  root = buildTree(nums)
  fmt.Println(binaryTreePaths(root))
}

输出:

[1->2->5 1->3]

[1]

代码2: DFS

package main
import (
  "fmt"
  "strconv"
)
const null = -1 << 31
type TreeNode struct {
  Val   int
  Left  *TreeNode
  Right *TreeNode
}
func binaryTreePaths(root *TreeNode) []string {
  var res []string
  if root == nil {
    return res
  }
  var path []string
  dfs(&res, path, root)
  return res
}
func dfs(res *[]string, path []string, node *TreeNode) {
  path = append(path, strconv.Itoa(node.Val))
  if node.Left == nil && node.Right == nil {
    *res = append(*res, getPath(path))
    return
  }
  if node.Left != nil {
    dfs(res, path, node.Left)
  }
  if node.Right != nil {
    dfs(res, path, node.Right)
  }
}
func getPath(path []string) string {
  var res string
  for i := 0; i < len(path)-1; i++ {
    res += path[i] + "->"
  }
  res += path[len(path)-1]
  return res
}
func buildTree(nums []int) *TreeNode {
  if len(nums) == 0 {
    return nil
  }
  root := &TreeNode{Val: nums[0]}
  Queue := []*TreeNode{root}
  idx := 1
  for idx < len(nums) {
    node := Queue[0]
    Queue = Queue[1:]
    if nums[idx] != null {
      node.Left = &TreeNode{Val: nums[idx]}
      Queue = append(Queue, node.Left)
    }
    idx++
    if idx < len(nums) && nums[idx] != null {
      node.Right = &TreeNode{Val: nums[idx]}
      Queue = append(Queue, node.Right)
    }
    idx++
  }
  return root
}
func main() {
  nums := []int{1, 2, 3, null, 5}
  root := buildTree(nums)
  fmt.Println(binaryTreePaths(root))
  nums = []int{1}
  root = buildTree(nums)
  fmt.Println(binaryTreePaths(root))
}

258. 各位相加 Add Digits

给定一个非负整数 num,反复将各个位上的数字相加,直到结果为一位数。返回这个结果。

示例 1:

输入: num =38

输出: 2

解释: 各位相加的过程为

38 --> 3 + 8 --> 11

11 --> 1 + 1 --> 2

由于 2 是一位数,所以返回 2。


示例 1:

输入: num =0

输出: 0


提示:

  • 0 <= num <= 2^31 - 1

进阶:你可以不使用循环或者递归,在 O(1) 时间复杂度内解决这个问题吗?

代码: 4种方法

package main
import  "fmt"
func addDigits(num int) int {
    if num < 10 {
        return num
    }
    sum := 0
    for num > 0 {
        sum += num % 10
        num /= 10
    }
    return addDigits(sum)
}
func addDigits2(num int) int {
    for num >= 10 {
        sum := 0
        for num > 0 {
            sum += num % 10
            num /= 10
        }
        num = sum
    }
    return num
}
func addDigits3(num int) int {
    if num == 0 {
        return 0
    } else if num % 9 == 0 {
        return 9
    } else {
        return num % 9
    }
}
func addDigits4(num int) int {
    return (num - 1) % 9 + 1
}
func main() {
    num := 38
    fmt.Println(addDigits(num))
    fmt.Println(addDigits2(num))
    fmt.Println(addDigits3(num))
    fmt.Println(addDigits4(num))
    num = 0
    fmt.Println(addDigits(num))
    fmt.Println(addDigits2(num))
    fmt.Println(addDigits3(num))
    fmt.Println(addDigits4(num))
}

输出:

2

2

2

2

0

0

0

0


🌟 每日一练刷题专栏 🌟

持续,努力奋斗做强刷题搬运工!

👍 点赞,你的认可是我坚持的动力!

🌟 收藏,你的青睐是我努力的方向!

评论,你的意见是我进步的财富!  

主页:https://hannyang.blog.csdn.net/

Rust每日一练 专栏

(2023.5.16~)更新中...

Golang每日一练 专栏

(2023.3.11~)更新中...

Python每日一练 专栏

(2023.2.18~2023.5.18)暂停更

C/C++每日一练 专栏

(2023.2.18~2023.5.18)暂停更

Java每日一练 专栏

(2023.3.11~2023.5.18)暂停更


目录
相关文章
|
4月前
|
Shell Linux 算法
Shell编程——弱数据类型的脚本语言快速入门指南
Shell编程——弱数据类型的脚本语言快速入门指南
57 0
Shell编程——弱数据类型的脚本语言快速入门指南
|
4月前
|
Go Linux Shell
Linux 终端命令之文件浏览(2) more
Linux 终端命令之文件浏览(2) more
33 0
Linux 终端命令之文件浏览(2) more
|
4月前
|
Shell 机器学习/深度学习 Linux
Linux 终端操作命令(2)内部命令
Linux 终端操作命令(2)内部命令
23 0
Linux 终端操作命令(2)内部命令
|
4月前
|
C++ 算法 存储
力扣 C++|一题多解之动态规划专题(2)
力扣 C++|一题多解之动态规划专题(2)
39 0
力扣 C++|一题多解之动态规划专题(2)
|
7天前
|
监控 算法 Go
Golang深入浅出之-Go语言中的服务熔断、降级与限流策略
【5月更文挑战第4天】本文探讨了分布式系统中保障稳定性的重要策略:服务熔断、降级和限流。服务熔断通过快速失败和暂停故障服务调用来保护系统;服务降级在压力大时提供有限功能以保持整体可用性;限流控制访问频率,防止过载。文中列举了常见问题、解决方案,并提供了Go语言实现示例。合理应用这些策略能增强系统韧性和可用性。
35 0
|
5天前
|
分布式计算 Java Go
Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
【5月更文挑战第6天】Apache Beam是一个统一的编程模型,适用于批处理和流处理,主要支持Java和Python,但也提供实验性的Go SDK。Go SDK的基本概念包括`PTransform`、`PCollection`和`Pipeline`。在使用中,需注意类型转换、窗口和触发器配置、资源管理和错误处理。尽管Go SDK文档有限,生态系统尚不成熟,且性能可能不高,但它仍为分布式计算提供了可移植的解决方案。通过理解和掌握Beam模型,开发者能编写高效的数据处理程序。
134 1
|
6天前
|
缓存 测试技术 持续交付
Golang深入浅出之-Go语言中的持续集成与持续部署(CI/CD)
【5月更文挑战第5天】本文介绍了Go语言项目中的CI/CD实践,包括持续集成与持续部署的基础知识,常见问题及解决策略。测试覆盖不足、版本不一致和构建时间过长是主要问题,可通过全面测试、统一依赖管理和利用缓存优化。文中还提供了使用GitHub Actions进行自动化测试和部署的示例,强调了持续优化CI/CD流程以适应项目需求的重要性。
45 1
|
6天前
|
Kubernetes Cloud Native Go
Golang深入浅出之-Go语言中的云原生开发:Kubernetes与Docker
【5月更文挑战第5天】本文探讨了Go语言在云原生开发中的应用,特别是在Kubernetes和Docker中的使用。Docker利用Go语言的性能和跨平台能力编写Dockerfile和构建镜像。Kubernetes,主要由Go语言编写,提供了方便的客户端库与集群交互。文章列举了Dockerfile编写、Kubernetes资源定义和服务发现的常见问题及解决方案,并给出了Go语言构建Docker镜像和与Kubernetes交互的代码示例。通过掌握这些技巧,开发者能更高效地进行云原生应用开发。
49 1
|
6天前
|
负载均衡 监控 Go
Golang深入浅出之-Go语言中的服务网格(Service Mesh)原理与应用
【5月更文挑战第5天】服务网格是处理服务间通信的基础设施层,常由数据平面(代理,如Envoy)和控制平面(管理配置)组成。本文讨论了服务发现、负载均衡和追踪等常见问题及其解决方案,并展示了使用Go语言实现Envoy sidecar配置的例子,强调Go语言在构建服务网格中的优势。服务网格能提升微服务的管理和可观测性,正确应对问题能构建更健壮的分布式系统。
27 1
|
7天前
|
消息中间件 Go API
Golang深入浅出之-Go语言中的微服务架构设计与实践
【5月更文挑战第4天】本文探讨了Go语言在微服务架构中的应用,强调了单一职责、标准化API、服务自治和容错设计等原则。同时,指出了过度拆分、服务通信复杂性、数据一致性和部署复杂性等常见问题,并提出了DDD拆分、使用成熟框架、事件驱动和配置管理与CI/CD的解决方案。文中还提供了使用Gin构建HTTP服务和gRPC进行服务间通信的示例。
23 0