二叉树的层序遍历（含八道leetcode相关题目）

原创 已于 2024-09-20 20:00:34 修改 · 563 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #算法 #golang

于 2024-09-19 00:12:16 首次发布

文章目录

二叉树层序遍历模板

我们之前讲过了关于二叉树的深度优先遍历的文章：前中后序遍历的递归法和迭代法。

接下来我们再来介绍二叉树的另一种遍历方式：层序遍历。

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

在这里插入图片描述
如图所示：将每层的元素从左至右加入队列，取出时就会先取出左节点，并将当前节点的左右节点又加入队尾，接着从队列取出下一个元素，将它的左右节点同样加入队尾，以此类推。那怎么确认取出多少个元素的时候可认为当前层的元素都取完了呢？这就需要一个变量来记录啦，这个变量其实就是每轮循环开始时队列的长度，当前长度就是当前层的所有元素，该轮循环的后续操作就是将下一层的所有节点加入队尾。

这样就实现了层序从左到右遍历二叉树。

代码如下：这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了。

Go代码如下

102. 二叉树的层序遍历

迭代法

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

    res := make([][]int,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)
    for len(queue) != 0 {
        // 当前层的元素个数，以及定义存当前层结果的数组
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        // 取出当前层所有元素，并依次加入下一层的元素
        for i := 0; i < queueSize ;i++ {
            curNode := queue[0]
            queue = queue[1:len(queue)]
            curLevelRes = append(curLevelRes,curNode.Val)
            // 当前节点的左右节点加入队列
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 当前层遍历完成，将当前层结果加入最终结果中
        res = append(res,curLevelRes)
    }

    return res
}

递归法

// 层序遍历递归法
func levelOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }

    res := make([][]int,0)
    preOrder(root,0,&res) //根节点在第0层

    return res
}

/*直接使用二叉树的前序遍历的递归形式即可，只是递归的时候，要多传一个参数，
 就是该节点属于第几层的，很简单，子节点所在层数是父节点所在层数加一*/
func preOrder(node *TreeNode,level int,res *[][]int) {
    //如果level是新层，则在res中继续添加一个[]int用于存这一次的结点的值
    if len(*res) == level {
        culLevelRes := make([]int,0)
        *res = append(*res,culLevelRes)
    }

    //将结点的值添加到res中对应的层的[]int中
    (*res)[level] = append((*res)[level],node.Val)
    //递归遍历左右子节点
    if node.Left != nil {
        preOrder(node.Left,level + 1,res)
    }
    if node.Right != nil {
        preOrder(node.Right,level + 1,res)
    }
}

在这里插入图片描述

102. 二叉树的层序遍历

102. 二叉树的层序遍历

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

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

Go 代码迭代法

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

    res := make([][]int,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)
    for len(queue) != 0 {
        // 当前层的元素个数，以及定义存当前层结果的数组
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        // 取出当前层所有元素，并依次加入下一层的元素
        for i := 0; i < queueSize ;i++ {
            curNode := queue[0]
            queue = queue[1:len(queue)]
            curLevelRes = append(curLevelRes,curNode.Val)
            // 当前节点的左右节点加入队列
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 当前层遍历完成，将当前层结果加入最终结果中
        res = append(res,curLevelRes)
    }

    return res
}

在这里插入图片描述

Go代码递归法

// 层序遍历递归法
func levelOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }

    res := make([][]int,0)
    preOrder(root,0,&res) //根节点在第0层

    return res
}

/*直接使用二叉树的前序遍历的递归形式即可，只是递归的时候，要多传一个参数，
 就是该节点属于第几层的，很简单，子节点所在层数是父节点所在层数加一*/
func preOrder(node *TreeNode,level int,res *[][]int) {
    //如果level是新层，则在res中继续添加一个[]int用于存这一次的结点的值
    if len(*res) == level {
        culLevelRes := make([]int,0)
        *res = append(*res,culLevelRes)
    }

    //将结点的值添加到res中对应的层的[]int中
    (*res)[level] = append((*res)[level],node.Val)
    //递归遍历左右子节点
    if node.Left != nil {
        preOrder(node.Left,level + 1,res)
    }
    if node.Right != nil {
        preOrder(node.Right,level + 1,res)
    }
}

在这里插入图片描述

107. 二叉树的层序遍历 II

107. 二叉树的层序遍历 II

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

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000

Go代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrderBottom(root *TreeNode) [][]int {
    // 和102题一样，就是普通的层序遍历，不过遍历完成后，结果需要倒序一下
    if root == nil {
        return [][]int{}
    }

    res := make([][]int,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)

    for len(queue) > 0 {
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        for i := 0;i < queueSize;i++{
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode.Val)
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        res = append(res,curLevelRes)
    }

    // 反转结果
    left := 0
    right := len(res)-1
    for left < right {
        res[left],res[right] = res[right],res[left]
        left++
        right--
    }

    return res
}

在这里插入图片描述

199. 二叉树的右视图

199. 二叉树的右视图

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

示例 1:

在这里插入图片描述

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

  • 二叉树的节点个数的范围是 [0,100]
  • -100 <= Node.val <= 100

Go代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func rightSideView(root *TreeNode) []int {
    // 层序遍历之后，返回每层最后一个元素即可
    if root == nil {
        return []int{}
    }

    res := make([]int,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)

    for len(queue) > 0 {
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        for i := 0;i < queueSize;i++{
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode.Val)
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 只保留当前层最右边的元素，即当前层最后一个元素
        res = append(res,curLevelRes[len(curLevelRes) - 1])
    }

    return res
}

在这里插入图片描述

637. 二叉树的层平均值

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 1 0 − 5 10^{-5} 10−5 以内的答案可以被接受。

示例 1：
在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:
在这里插入图片描述

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

  • 树中节点数量在 [1, 104] 范围内
  • -2^31 <= Node.val <= 2^31 - 1

Go代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func averageOfLevels(root *TreeNode) []float64 {
    // 层序遍历之后，返回每层的平均值即可
    if root == nil {
        return []float64{}
    }

    res := make([]float64,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)

    for len(queue) > 0 {
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        for i := 0;i < queueSize;i++{
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode.Val)
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 只保留当前层最右边的元素，即当前层最后一个元素
        res = append(res,getAvgOfArr(curLevelRes))
    }

    return res
}

func getAvgOfArr(arr []int) float64 {
    sum := 0
    for _,num:= range arr {
        sum += num
    }
    
    return float64(sum) / float64(len(arr))
}

在这里插入图片描述

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

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

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

示例1：

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

示例2：

输入: root = [1,2,3]
输出: [1,3]

提示：

  • 二叉树的节点个数的范围是 [ 0 , 1 0 4 ] [0,10^4] [0,104]
  • − 2 31 < = N o d e . v a l < = 2 31 − 1 -2^{31} <= Node.val <= 2^{31} - 1 −231<=Node.val<=231−1

Go代码

代码和637题几乎一样

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func largestValues(root *TreeNode) []int {
    // 层序遍历之后，返回每层的最大值即可
    if root == nil {
        return []int{}
    }

    res := make([]int,0)
    queue := make([]*TreeNode,0)
    queue = append(queue,root)

    for len(queue) > 0 {
        queueSize := len(queue)
        curLevelRes := make([]int,0)
        for i := 0;i < queueSize;i++{
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode.Val)
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 只保留当前层最右边的元素，即当前层最后一个元素
        res = append(res,getMaxOfArr(curLevelRes))
    }

    return res
}

func getMaxOfArr(arr []int) int {
    maxVal := arr[0]
    for _,num:= range arr {
        if num > maxVal {
            maxVal = num
        }
    }
    
    return maxVal
}

在这里插入图片描述

429. N 叉树的层序遍历

429. N 叉树的层序遍历

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

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

示例 1：

在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：
在这里插入图片描述

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

  • 树的高度不会超过 1000
  • 树的节点总数在 [0, 10^4] 之间

Go 代码

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

func levelOrder(root *Node) [][]int {
    // 思路和102题二叉树的层序遍历是一模一样的
    if root == nil {
        return [][]int{}
    }

    res := make([][]int,0)
    queue := make([]*Node,0)
    queue = append(queue,root)

    for len(queue) > 0 {
        curLevelRes := make([]int,0)
        queueSize := len(queue)
        for i := 0;i < queueSize;i++ {
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode.Val)
            // 下一层,与二叉树层序遍历的唯一区别
            for j := 0;j < len(curNode.Children);j++{
                queue = append(queue,curNode.Children[j])
            }
        }
        res = append(res,curLevelRes)
    }

    return res
}

在这里插入图片描述

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

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

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：
在这里插入图片描述

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next指针连接，‘#’ 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

提示：

  • 树中节点的数量在 [0, 2^12 - 1] 范围内
  • -1000 <= node.val <= 1000

进阶：

  • 你只能使用常量级额外空间。
  • 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

Go 代码

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

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

    queue := make([]*Node,0)
    queue = append(queue,root)
    for len(queue) != 0 {
        // 当前层的元素个数，以及定义存当前层结果的数组
        queueSize := len(queue)
        curLevelRes := make([]*Node,0)
        // 取出当前层所有元素，并依次加入下一层的元素
        for i := 0; i < queueSize ;i++ {
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode)
            // 当前节点的左右节点加入队列
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 当前层遍历完成，当前层的节点前一个节点的Next连接同层节点的下一个节点
        for i := 0;i < len(curLevelRes) - 1;i++ {
            curLevelRes[i].Next = curLevelRes[i+1]
        }
    }

    return root
}

在这里插入图片描述

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

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

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：

在这里插入图片描述

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。

示例 2：

输入：root = []
输出：[]

提示：

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

进阶：

  • 你只能使用常量级额外空间。
  • 使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。

Go代码

与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 nil
    }

    queue := make([]*Node,0)
    queue = append(queue,root)
    for len(queue) != 0 {
        // 当前层的元素个数，以及定义存当前层结果的数组
        queueSize := len(queue)
        curLevelRes := make([]*Node,0)
        // 取出当前层所有元素，并依次加入下一层的元素
        for i := 0; i < queueSize ;i++ {
            curNode := queue[0]
            queue = queue[1:]
            curLevelRes = append(curLevelRes,curNode)
            // 当前节点的左右节点加入队列
            if curNode.Left != nil {
                queue = append(queue,curNode.Left)
            }
            if curNode.Right != nil {
                queue = append(queue,curNode.Right)
            }
        }
        // 当前层遍历完成，当前层的节点前一个节点的Next连接同层节点的下一个节点
        for i := 0;i < len(curLevelRes) - 1;i++ {
            curLevelRes[i].Next = curLevelRes[i+1]
        }
    }

    return root
}

在这里插入图片描述

leetcode—19.二叉树遍历相关题目leetcode总结
柳杰的博客
04-28 431
文章目录引言一、深度优先遍历144. 二叉树的前序遍历94. 二叉树的中序遍历145. 二叉树的后序遍历二、广度优先遍历102. 二叉树的层序遍历103. 二叉树的锯齿形层序遍历 引言   二叉树遍历即将二叉树按照某种顺序访问一遍，涉及深度优先遍历与广度优先遍历。深度优先遍历可分为前序遍历、中序遍历、后序遍历。广度优先遍历包括层次遍历，层序遍历可分为自顶向下层序遍历，自底向上层序遍历，锯齿层序遍历。 一、深度优先遍历   一般都有递归与迭代思路，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显
二叉树的典型习题总结
qq_41185460的博客
01-19 5036
二叉树的三种遍历方式： 1.给定一个二叉树，返回它的前序遍历。root-left-right 递归实现： public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); //每次遍历都会产生一个新的...
二叉树大总结1_二叉树的各种题(遍历、查找)
12-09
二叉树大总结1_二叉树的各种题(遍历、查找等)，是网上一个不错的学习例子。
二叉树遍历相关题目
drboom111的博客
07-31 5582
二叉树遍历相关题目
二叉树练习题（一） 二叉树的遍历
热门推荐
weixin_41611045的博客
10-19 1万+
例题1：对于上述二叉树，请实现层次遍历、先序遍历、中序遍历和后序遍历 ''' 二叉树的遍历 将以下二叉树分别用先序遍历、中序遍历、后序遍历和层次遍历进行遍历 0 1 2 3 4 5 6 7 8 9 先序遍历：中左右 中序遍历：左中右 后序遍历：左右中 ''' class TreeNode: def __init__(self, x): ...
二叉树的遍历以及笔试题
qq_34896730的博客
08-17 1万+
本篇介绍二叉树最常见的三种遍历方式：先序、中序和后序遍历方式。 1、定义       二叉树是由3个基本单元组成：根节点、左子树和右子树。因此，若能依次遍历这三部分，便是遍历了整个二叉树。例如从L、D、R分别表示遍历左子树、访问根节点和遍历右子树，则可有DLR、LDR、LRD、DRL、RDL、RLD这6种遍历二叉树的方案。若限定先左后右，则只有前3种情况，分别称为先(根)序遍历、中(根)序遍历和后(根)序遍历。基于二叉树的递归定义，可得下述遍历二叉
二叉树层序遍历相关题目
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
07-21 1487
刷题路线来自代码随想录。
二叉树层序遍历 及相关题目
qq_62319385的博客
04-04 1340
1，力扣102给你二叉树的根节点root，返回其节点值的。（即逐层地，从左到右访问所有节点）。root = [1][[1]]root = [][][0, 2000]2，力扣107 二叉树遍历II给你二叉树的根节点root，返回其节点值。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）root = [1][[1]]root = [][][0, 2000]3， 力扣199二叉树的右视图给定一个二叉树的root。
二叉树遍历
iron的博客
08-04 1045
题目1184：二叉树遍历 时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：1562 解决：621 题目描述： 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入： ...
LeetCode：二叉树的遍历方式（13道经典题目）
一起加油~
03-31 3727
二叉树的遍历方式（前序遍历、后序遍历、中序遍历以及层序遍历）以及LeetCode相关题目。
5.8.由遍历序列构造二叉树
最新发布
ADCvbV的博客
10-15 1666
根结点为A，它的左子结点为B，没有右子结点，根结点为A，没有左子结点，它的右子结点为B，显然这是两棵不同的二叉树，但他们的前/后/层序遍历序列都一样，因此前序，后序，层序遍历序列的两两组合无法唯一确定一棵二叉树，要想唯一确定一棵二叉树，必须要与中序遍历序列组合。
数据结构7：基本的二叉树遍历及题目
m0_53607711的博客
12-20 930
类笔记型文章，纯记述
11道精选经典LeetCode例题让你彻底搞懂二叉树的广度优先遍历
wenwenaier的博客
12-04 2596
文章目录1.二叉树的层序遍历|2.二叉树的层序遍历||3.二叉树的右视图4.二叉树的层平均值5.n叉树的层数遍历6.在每个树行找最大值7.填充每个节点的下一个右侧节点指针8.填充每个节点的下一个右侧节点指针||9.二叉树的最大深度10.二叉树的最小深度11.翻转二叉树 相见即是有缘，如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ 广度优先搜索是遍历二叉树的一种基本方式，也就是层序遍历一个二叉树。从左到右一层一层的去遍历二叉树，对此我们需要借助数据结构队列来完成，因为队列先进先出的特点符合我们遍历
二叉树的遍历+基础练习
weixin_53316121的博客
04-14 8658
前面完全二叉树适合存放数据，又因为它在内存中连续存储，因此用顺序表来实现它，并介绍了堆排序及TOP-K问题。 今天我们了解一下二叉树的遍历问题，并完成几道二叉树基础OJ题目。 二叉树的遍历 二叉树的遍历有：前序/中序/后序的递归结构遍历： 1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之间。 3. 后序遍历(Postorder Trave
二叉树的层次遍历（10道）
Wangtffn的博客
09-06 653
（写给未来遗忘的自己）
常见二叉树及例题汇总
kyle的博客
05-29 4221
常见二叉树及例题汇总（更新中）
Codeup——611 | 问题 D: 二叉树遍历
qq_44888152的博客
10-12 631
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b
二叉树经典的选择题（带你轻松理解）
weixin_72040293的博客
04-03 2898
讲解二叉树常见的三种选择题题型
二叉树的多种遍历方法
愿岁月如歌
03-16 2375
二叉树遍历学习 1.给出满二叉树的前序遍历建树。   #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; //前提是已知树是满的 char cache[101]; typedef struct Node { char data; struct Node *lchild,*rchild; }; struct Node *ro...
二叉树层序遍历题解：Python实现LeetCode第102题
资源摘要信息:"本资源是关于Python编程语言在leetcode网站解决第102题二叉树层序遍历问题的题解。第102题要求开发者实现对给定二叉树进行层序遍历并返回遍历结果，输出每一层的节点值。层序遍历是一种广度优先搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值