算法训练第12天|226.翻转二叉树|101. 对称二叉树|104.二叉树的最大深度|111.二叉树的最小深度

LeetCode 226.翻转二叉树

题目链接：226.翻转二叉树

题目讲解：代码随想录

题目描述：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

层序遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func invertTree(root *TreeNode) *TreeNode {
    if root == nil{
        return root 
    }

    curLevel := []*TreeNode{root}
    for len(curLevel) > 0{
        nextLevel := []*TreeNode{}

        for _, node := range curLevel{

            node.Left, node.Right = node.Right, node.Left

            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }

            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }

        }
        curLevel = nextLevel
    }

    return root
}

LeetCode 101. 对称二叉树

题目链接：101. 对称二叉树

题目讲解：代码随想录

题目描述：给你一个二叉树的根节点 root ， 检查它是否轴对称。

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    return defs(root.Left, root.Right)
}

func defs(left *TreeNode, right *TreeNode) bool{
    if left == nil && right == nil{
        return true
    }

    if left == nil || right == nil{ // 只有一边为nil
        return false
    }

    if left.Val != right.Val{ // 两边有值但不相等
        return false
    }

    // 要对称
    return defs(left.Left, right.Right) && defs(left.Right, right.Left)
}

LeetCode 104.二叉树的最大深度

题目链接：104.二叉树的最大深度

题目讲解：代码随想录

题目描述：给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）

使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    res := 0

    if root == nil{
        return res
    }

    curLevel := []*TreeNode{root}
    for len(curLevel) > 0{
        nextLevel := []*TreeNode{}
        for _, node := range curLevel{

            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }

            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }
        }
        curLevel = nextLevel
        res++
    }

    return res
}

LeetCode 111.二叉树的最小深度

题目链接：111.二叉树的最小深度

题目讲解：代码随想录

题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。

使用迭代法，需要注意的是，只有当左右孩子都为空的时候，才说明遍历到最低点了。如果其中一个孩子不为空则不是最低点。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func minDepth(root *TreeNode) int {
    res := 0

    if root == nil{
        return res
    }

    curLevel := []*TreeNode{root}

    for len(curLevel) > 0{
        nextLevel := []*TreeNode{}

        for _, node := range curLevel{

            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }

            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }

            if node.Right == nil && node.Left == nil{
                return res + 1
            }

        }
        curLevel = nextLevel
        res++
    }

    return res
}