每日编程(43）---二叉树
题目：二叉树的层次遍历 II
题目描述：
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其自底向上的层次遍历为：
[
[15,7],
[9,20],
[3]
]
分析：
二叉树层析遍历，借助队列，每次要将当前队列遍历完毕，因为当前队列储存的就是一层的节点，最后他要求反转输出，这个办法就多了
代码：
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func levelOrderBottom(root *TreeNode) [][]int {
res:=[][]int{}
if root==nil{
return res
}
re:=[]int{}
re=append(re,root.Val)
res=append(res,re)
arr:=[]*TreeNode{}
arr=append(arr,root)
for len(arr)!=0{
num:=[]int{}
i:=0
n:=len(arr) //只取当前队列中的数量
for i=0;i--{
ret=append(ret,res[i])
}
return ret
}
题目：二叉树的层平均值
题目描述：
给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.
示例 1:
输入:
3
/
9 20
/
15 7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3, 第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
分析：
同样的层次遍历过程，只是每次求的是平均值
代码：
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func averageOfLevels(root *TreeNode) []float64 {
res:=[]float64{}
if root==nil{
return res
}
//res=append(res,root.Val)
num:=[]*TreeNode{}
num=append(num,root)
for len(num)!=0{
sum:=0
n:=len(num)
i:=0
for i题目：翻转二叉树
题目描述：
翻转一棵二叉树。
示例：
输入：
4
/
2 7
/ \ /
1 3 6 9
输出：
4
/
7 2
/ \ /
9 6 3 1
分析：
像这种题，肯定递归了，每次交换当前节点的左右节点，如果当前节点是叶节点，不进行任何操作
代码：
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func invertTree(root *TreeNode) *TreeNode {
if root==nil{
return nil
}
if root.Left!=nil && root.Right!=nil{
tmp:=root.Left
root.Left=root.Right
root.Right=tmp
invertTree(root.Left)
invertTree(root.Right)
}else if root.Left!=nil && root.Right==nil{
root.Right=root.Left
root.Left=nil
invertTree(root.Right)
}else if root.Left==nil && root.Right!=nil{
root.Left=root.Right
root.Right=nil
invertTree(root.Left)
}else{
}
return root
}
题目： 二叉树的所有路径
题目描述：
给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
输入:
1
/
2 3
5
输出: [“1->2->5”, “1->3”]
解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
分析：
中心思想还是递归，先判断当前节点的状态，如果是叶节点，就直接加上当前节点的值，并将改字符串追加到切片中返回，
如果不是，加上当前节点的值，继续递归他的左右节点，知道为nil或者是叶节点。
代码：
func binaryTreePaths(root *TreeNode) []string {
res:=[]string{}
var path string
path=""
res=find(root,res,path)
fmt.Println(res)
return res
}
func find(root *TreeNode,res []string,path string)[]string{
if root==nil{
return res
}
if path==""{
path+=strconv.Itoa(root.Val)
}else{
path+="->"
path+=strconv.Itoa(root.Val)
}
if root.Left==nil && root.Right==nil{
res=append(res,path)
return res
}
res=find(root.Left,res,path)
res=find(root.Right,res,path)
return res
}