算法训练第11天|144.二叉树的前序遍历|145.二叉树的后序遍历|94.二叉树的中序遍历及其应用

于 2024-08-12 13:15:21 发布
阅读量714 收藏 13
点赞数 18
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42813810/article/details/141128324
版权

LeetCode 144.二叉树的前序遍历

题目链接：144.二叉树的前序遍历

题目讲解：代码随想录

题目描述：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

前序遍历的顺序是：中左右

递归法：

func preorderTraversal(root *TreeNode) (res []int) {
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode){
        if node == nil{
            return
        }

        res = append(res, node.Val)
        traversal(node.Left)
        traversal(node.Right)
    }
    traversal(root)
    return res
}

迭代法：

func preorderTraversal(root *TreeNode) []int {
    ans := []int{}

    if root == nil{
        return ans
    }

    st := list.New()
    st.PushBack(root)

    for st.Len() > 0{
        node := st.Remove(st.Back()).(*TreeNode)

        ans = append(ans, node.Val)
        if node.Right != nil{
            st.PushBack(node.Right)
        }
        if node.Left != nil{
            st.PushBack(node.Left)
        }
    }

    return ans
}

LeetCode 145.二叉树的后序遍历

题目链接：145.二叉树的后序遍历

题目讲解：代码随想录

题目描述：给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

后续遍历的顺序是：左右中

递归法：

func postorderTraversal(root *TreeNode) (res []int) {
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode){
        if node == nil{
            return 
        }

        traversal(node.Left)
        traversal(node.Right)
        res = append(res, node.Val)
    }

    traversal(root)
    return res
}

迭代法：

func postorderTraversal(root *TreeNode) []int {
    ans := []int{}

    if root == nil{
        return ans
    }

    st := list.New()
    st.PushBack(root)

    for st.Len() > 0{
        node := st.Remove(st.Back()).(*TreeNode)

        ans = append(ans, node.Val)

        if node.Left != nil{
            st.PushBack(node.Left)
        }

        if node.Right != nil{
            st.PushBack(node.Right)
        }
    }

    reverse(ans)
    return ans
}

func reverse(list []int){
    left := 0
    right := len(list) - 1

    for left < right{
        list[left], list[right] = list[right], list[left]
        left++
        right--
    }
}

LeetCode 94.二叉树的中序遍历

题目链接： 94.二叉树的中序遍历

题目讲解：代码随想录

题目描述：给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

中序遍历的顺序是：左中右

递归法：

func inorderTraversal(root *TreeNode) (res []int) {
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode){
        if node == nil{
            return
        }

        traversal(node.Left)
        res = append(res, node.Val)
        traversal(node.Right)
    }
    traversal(root)
    return res
}

迭代法： 

func inorderTraversal(root *TreeNode) []int{
    ans := []int{}
    if root == nil{
        return ans
    }

    st := list.New()
    cur := root

    for cur != nil || st.Len() > 0{
        if cur != nil{
            st.PushBack(cur)
            cur = cur.Left
        }else{
            cur = st.Remove(st.Back()).(*TreeNode)
            ans = append(ans, cur.Val)
            cur = cur.Right
        }
    }
    return ans
}

 LeetCode 102.二叉树的层序遍历

题目链接：102.二叉树的层序遍历

题目讲解：代码随想录

题目描述：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

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

    if root == nil{
        return res
    }

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

        for _, node := range curLevel{
            vals = append(vals, node.Val)

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

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

        res = append(res, vals)
        curLevel = nextLevel
    }
    return res
}

LeetCode 107.二叉树的层次遍历 II

题目链接：107.二叉树的层次遍历 II

题目讲解：代码随想录

题目描述：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrderBottom(root *TreeNode) [][]int {
    ans := [][]int{}

    if root == nil{
        return ans
    }

    curLevel := []*TreeNode{root}

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

        for _, node := range curLevel{
            vals = append(vals, node.Val)
            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }
            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }
        }

        ans = append(ans, vals)
        curLevel = nextLevel
    }

    Reverse(ans)
    return ans
}

func Reverse(list [][]int){
    l := 0
    r := len(list) - 1

    for l < r{
        list[l], list[r] = list[r], list[l]
        l++
        r--
    }
}

LeetCode 199.二叉树的右视图

题目链接：199.二叉树的右视图

题目讲解：代码随想录

题目描述：给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

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

    if root == nil{
        return res
    }

    curLevel := []*TreeNode{root}

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

        for i, node := range curLevel{
            
            if node.Left != nil{
                nextLevel = append(nextLevel, node.Left)
            }
            if node.Right != nil{
                nextLevel = append(nextLevel, node.Right)
            }

            if i == size - 1{
                res = append(res, node.Val)
            }
        }

        curLevel = nextLevel
    }
    return res
}

LeetCode 637.二叉树的层平均值

题目链接：637.二叉树的层平均值

题目讲解：代码随想录

题目描述：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

本题就是层序遍历的时候把一层求个总和再取一个均值。

/**
 * 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
    }

    curLevel := []*TreeNode{root}

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

        for _, node := range curLevel{

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

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

            sum += float64(node.Val)
        }

        res = append(res, sum/float64(length))
        curLevel = nextLevel
    }
    return res
}

LeetCode 429.N叉树的层序遍历

题目链接：429.N叉树的层序遍历

题目讲解：代码随想录

题目描述：给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔。

这道题依旧是模板题，只不过一个节点有多个孩子了

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Children []*Node
 * }
 */

func levelOrder(root *Node) [][]int {
    res := [][]int{}

    if root == nil{
        return res
    }

    curLevel := []*Node{root}

    for len(curLevel) > 0{
        nextLevel := []*Node{}
        vals := []int{}

        for _, node := range curLevel{
            vals = append(vals, node.Val)

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

        res = append(res, vals)
        curLevel = nextLevel
    }
    return res
}

LeetCode 515.在每个树行中找最大值

题目链接：515.在每个树行中找最大值

题目讲解：代码随想录

题目描述：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

 层序遍历，取每一层的最大值

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

    if root == nil{
        return res
    }

    curLevel := []*TreeNode{root}

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

        for _, node := range curLevel{

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

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

            if node.Val > max{
                max = node.Val
            }
        }

        res = append(res, max)
        curLevel = nextLevel
    }
    return res
}

LeetCode 116.填充每个节点的下一个右侧节点指针

题目链接：116.填充每个节点的下一个右侧节点指针

题目讲解：代码随想录

题目描述：给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Left *Node
 *     Right *Node
 *     Next *Node
 * }
 */

func connect(root *Node) *Node {

	if root == nil{
        return root
    }

    curLevel := []*Node{root}

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

        for i := 0; i < len(curLevel); i++{
            if i != length -1 {
                curLevel[i].Next = curLevel[i+1]
            }
        }

        for _, node := range curLevel{

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

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

        curLevel = nextLevel
    }

    return root
}

LeetCode 117.填充每个节点的下一个右侧节点指针II

题目链接：117.填充每个节点的下一个右侧节点指针II

题目讲解：代码随想录

题目描述：填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。初始状态下，所有 next 指针都被设置为 NULL 。

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Left *Node
 *     Right *Node
 *     Next *Node
 * }
 */

func connect(root *Node) *Node {
	
	if root == nil{
        return root
    }

    curLevel := []*Node{root}

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

        for i := 0; i < len(curLevel); i++{
            if i != length -1 {
                curLevel[i].Next = curLevel[i+1]
            }
        }

        for _, node := range curLevel{

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

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

        curLevel = nextLevel
    }

    return root
}

 LeetCode 104.二叉树的最大深度

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

题目讲解：代码随想录

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

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

/**
 * 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.二叉树的最小深度

题目讲解：代码随想录

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

相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。

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

/**
 * 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
}

piaoyuani
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值