每日编程(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<n{
            tmp:=arr[0]
            arr=arr[1:]
            i++
            if tmp.Left!=nil{
                 num=append(num,tmp.Left.Val)
                arr=append(arr,tmp.Left)
            }
            if tmp.Right!=nil{
                num=append(num,tmp.Right.Val)
                arr=append(arr,tmp.Right)
            }
            
        }
        res=append(res,num)
    }
    n:=len(res)
    ret:=[][]int{}
    for i:=n-2;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<n{
            tmp:=num[0]
            sum+=tmp.Val
            num=num[1:]
            i++
            if tmp.Left!=nil{
                num=append(num,tmp.Left)
            }
            if tmp.Right!=nil{
                num=append(num,tmp.Right)
            }
           
    }
      
            res=append(res,float64(sum)/float64(n))  
        
       
}
    return res
}

题目：翻转二叉树

题目描述：
翻转一棵二叉树。

示例：

输入：

 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
}