leetcode二叉树必刷题（1）——二叉树的前序遍历、二叉树的中序遍历、二叉树的后序遍历、二叉树的层序遍历、二叉树的层序遍历、II 二叉树的右视图、二叉树的层平均值

最新推荐文章于 2024-06-02 22:16:46 发布
最新推荐文章于 2024-06-02 22:16:46 发布
阅读量124 收藏
点赞数
分类专栏： 算法 # 力扣 文章标签： leetcode 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63230155/article/details/134649505
版权

文章目录

二叉树的前序遍历

题目链接

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

示例 1：

image-20231125133405965

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

示例 2：

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

示例 3：

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

示例 4：

image-20231125133446685

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

示例 5：

image-20231125133501925

输入：root = [1,null,2]
输出：[1,2]

提示：

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

Python：

#递归法
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        out = []
        self.preOrder(root, out)
        return out

    def preOrder(self, node: TreeNode, nums: [int]):
        if not node:
            return nums
        nums.append(node.val)
        self.preOrder(node.left, nums)
        self.preOrder(node.right, nums)

#迭代法
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        vals = list()
        stack = []
        node = root
        while node or stack:
            while node:
                vals.append(node.val)
                stack.append(node)
                node = node.left
            node = stack[-1].right
            stack = stack[:-1]
        return vals

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        return [root.val, *self.preorderTraversal(root.left), *self.preorderTraversal(root.right)]

#Morris 遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = list()
        if not root:
            return res

        p1 = root
        while p1:
            p2 = p1.left
            if p2:
                while p2.right and p2.right != p1:
                    p2 = p2.right
                if not p2.right:
                    res.append(p1.val)
                    p2.right = p1
                    p1 = p1.left
                    continue
                else:
                    p2.right = None
            else:
                res.append(p1.val)
            p1 = p1.right

        return res

Go：

//递归法
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func preorderTraversal(root *TreeNode) (out []int) {
	return preOrder(root, out)
}

func preOrder(node *TreeNode, nums []int) []int {
	if node == nil {
		return nums
	}
	nums = append(nums, node.Val)
	nums = preOrder(node.Left, nums)
	nums = preOrder(node.Right, nums)
	return nums
}

//递归法
func preorderTraversal(root *TreeNode) (out []int) {
	var preOrder func(*TreeNode)
	preOrder = func(node *TreeNode) {
		if node == nil {
			return
		}
		out = append(out, node.Val)
		preOrder(node.Left)
		preOrder(node.Right)
	}
	preOrder(root)
	return
}

//迭代法
func preorderTraversal(root *TreeNode) (vals []int) {
	var stack []*TreeNode
    for root != nil || len(stack) > 0 {
        for root != nil {
            vals = append(vals, root.Val)
            stack = append(stack, root)
            root = root.Left
        }
        root = stack[len(stack)-1].Right
        stack = stack[:len(stack)-1]
    }
    return
}

//Morris 遍历
func preorderTraversal(root *TreeNode) (vals []int) {
    // p1，p2定义当前节点和其左子节点
    var p1, p2 *TreeNode = root, nil

    // 循环遍历，直到当前节点为空
    for p1 != nil {
        p2 = p1.Left // 此处开始处理当前节点的左子树
        if p2 != nil {
            // 查找当前节点在其左子树中的前驱节点
            for p2.Right != nil && p2.Right != p1 {
                p2 = p2.Right
            }
            // 如果前驱节点的右子节点为空，则将前驱节点的右子节点设置为当前节点
            if p2.Right == nil {
                // 前序遍历，先访问当前节点
                vals = append(vals, p1.Val)
                // 将前驱节点的右子节点设置为当前节点，这样在后续遍历中可以通过此链接再次访问到当前节点
                p2.Right = p1
                // 访问当前节点的左子树
                p1 = p1.Left
                continue
            }
            // 如果前驱节点的右子节点不为空，则表示已经遍历完当前节点的左子树，需要断开链接
            p2.Right = nil
        } else {
            // 如果当前节点没有左子树，则直接访问当前节点
            vals = append(vals, p1.Val)
        }
        // 处理当前节点的右子树
        p1 = p1.Right
    }
    return
}

二叉树的中序遍历

题目链接

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

示例 1：

image-20231125143651686

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

示例 2：

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

示例 3：

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

提示：

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

Python：

# 递归法
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        out = []

        def inorder(node: TreeNode):
            if node:
                inorder(node.left)
                out.append(node.val)
                inorder(node.right)

        inorder(root)
        return out

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        stack = []
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            res.append(root.val)
            root = root.right
        return res

#Morris 遍历
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        while root:
            if root.left:
                # 找到当前节点的左子树中的中序遍历的最后一个节点，即当前节点在中序遍历中的前驱节点
                predecessor = root.left
                while predecessor.right and predecessor.right != root:
                    predecessor = predecessor.right
                
                if not predecessor.right:
                    # 如果前驱节点的右指针为空，将其指向当前节点，然后遍历左子树
                    predecessor.right = root
                    root = root.left
                else:
                    # 如果前驱节点的右指针已经指向当前节点，说明左子树已经遍历完成，将前驱节点的右指针恢复为空
                    predecessor.right = None
                    # 将当前节点的值加入结果集
                    res.append(root.val)
                    # 遍历右子树
                    root = root.right
            else:
                # 如果没有左子树，将当前节点的值加入结果集，然后遍历右子树
                res.append(root.val)
                root = root.right

        return res

Go：

//递归法
func inorderTraversal(root *TreeNode) (out []int) {
	var inOrder func(node *TreeNode)
	inOrder = func(node *TreeNode) {
		if node == nil {
			return
		}
		inOrder(node.Left)
		out = append(out, node.Val)
		inOrder(node.Right)
	}
	inOrder(root)
	return
}

//迭代法
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func inorderTraversal(root *TreeNode) (res []int) {
	var stack []*TreeNode
	for root != nil || len(stack) > 0 {
		for root != nil {
			stack = append(stack, root)
			root = root.Left
		}
		root = stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		res = append(res, root.Val)
		root = root.Right
	}
	return
}

//Morris 遍历
func inorderTraversal(root *TreeNode) (res []int) {
	for root != nil {
		if root.Left != nil {
			// predecessor 节点表示当前 root 节点向左走一步，然后一直向右走至无法走为止的节点
			predecessor := root.Left
			for predecessor.Right != nil && predecessor.Right != root {
				// 有右子树且没有设置过指向 root，则继续向右走
				predecessor = predecessor.Right
			}
			if predecessor.Right == nil {
				// 将 predecessor 的右指针指向 root，这样后面遍历完左子树 root.Left 后，就能通过这个指向回到 root
				predecessor.Right = root
				// 遍历左子树
				root = root.Left
			} else { // predecessor 的右指针已经指向了 root，则表示左子树 root.Left 已经访问完了
				res = append(res, root.Val)
				// 恢复原样
				predecessor.Right = nil
				// 遍历右子树
				root = root.Right
			}
		} else { // 没有左子树
			res = append(res, root.Val)
			// 若有右子树，则遍历右子树
			// 若没有右子树，则整颗左子树已遍历完，root 会通过之前设置的指向回到这颗子树的父节点
			root = root.Right
		}
	}
	return
}

二叉树的后序遍历

题目链接

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

示例 1：

image-20231125143343843

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

示例 2：

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

示例 3：

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

提示：

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

Python：

# 递归法
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        out = []

        def postOrder(node):
            if not node:
                return
            postOrder(node.left)
            postOrder(node.right)
            out.append(node.val)

        postOrder(root)
        return out

#迭代法
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        out = []
        stack = []
        lastVisit = None

        while root or stack:
            while root:
                stack.append(root)
                root = root.left

            node = stack[-1]

            if not node.right or node.right == lastVisit:
                out.append(node.val)
                stack.pop()
                lastVisit = node
            else:
                root = node.right

        return out

#Morris 遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        def addPath(node: TreeNode):
            count = 0
            while node:
                count += 1
                res.append(node.val)
                node = node.right
            i, j = len(res) - count, len(res) - 1
            while i < j:
                res[i], res[j] = res[j], res[i]
                i += 1
                j -= 1
        
        if not root:
            return list()
        
        res = list()
        p1 = root

        while p1:
            p2 = p1.left
            if p2:
                while p2.right and p2.right != p1:
                    p2 = p2.right
                if not p2.right:
                    p2.right = p1
                    p1 = p1.left
                    continue
                else:
                    p2.right = None
                    addPath(p1.left)
            p1 = p1.right
        
        addPath(root)
        return res

Go：

//递归法
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) (out []int) {
	var postOrder func(*TreeNode)
	postOrder = func(node *TreeNode) {
		if node == nil {
			return
		}
		postOrder(node.Left)
		postOrder(node.Right)
		out = append(out, node.Val)
	}
	postOrder(root)
	return
}

//迭代法
func postorderTraversal(root *TreeNode) []int {
	var stack []*TreeNode
	var result []int

	var prev *TreeNode // To keep track of the previously visited node

	for root != nil || len(stack) > 0 {
		for root != nil {
			stack = append(stack, root)
			root = root.Left
		}

		top := stack[len(stack)-1]

		// Check if the right subtree is nil or already visited
		if top.Right == nil || top.Right == prev {
			result = append(result, top.Val)
			stack = stack[:len(stack)-1]
			prev = top
		} else {
			// Move to the right subtree
			root = top.Right
		}
	}

	return result
}


//Morris 遍历
func reverse(a []int) {
    // 此函数用于反转一个切片
    for i, n := 0, len(a); i < n/2; i++ {
        a[i], a[n-1-i] = a[n-1-i], a[i] // 交换前后对应的元素
    }
}

func postorderTraversal(root *TreeNode) (res []int) {
    addPath := func(node *TreeNode) {
        resSize := len(res)
        for ; node != nil; node = node.Right { // 从输入的节点开始，不断向它的右子树方向遍历
            res = append(res, node.Val) // 将节点的值添加到结果数组中
        }
        reverse(res[resSize:]) // 反转结果数组中新增的部分（详见reverse函数注释）
    }

    p1 := root // 从根节点开始遍历
    for p1 != nil {
        if p2 := p1.Left; p2 != nil { // 如果左子树存在
            for p2.Right != nil && p2.Right != p1 {
                p2 = p2.Right // 不断向右子树方向遍历
            }
            if p2.Right == nil { // 如果右子树不存在
                p2.Right = p1 // 设置右子树为当前的根节点
                p1 = p1.Left // 将新的根节点设置为原根节点的左子树
                continue
            }
            p2.Right = nil // 清除右子树
            addPath(p1.Left) // 对左子树进行后序遍历
        }
        p1 = p1.Right // 遍历右子树
    }
    addPath(root) // 对整个树进行后序遍历
    return
}

二叉树的层序遍历

题目链接

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

示例 1：

image-20231126163346081

输入：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

Python：

# I. 按层打印： 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。
# II. 每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        out = []
        q = [root]
        while q:
            tmp = []
            l = len(q)
            for i in range(l):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            out.append(tmp)
        return out

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(tmp)
        return res

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        out = []
        q = [root]
        i = 0
        while q:
            p = []
            out.append([])
            for j in range(len(q)):
                node = q[j]
                out[i].append(node.val)
                if node.left:
                    p.append(node.left)
                if node.right:
                    p.append(node.right)
            q = p
            i += 1
        return out

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        result = []
        queue = [root]
        while queue:
            vals = []
            next_level = []
            for n in queue:
                vals.append(n.val)
                if n.left:
                    next_level.append(n.left)
                if n.right:
                    next_level.append(n.right)
            result.append(vals)
            queue = next_level
        return result

# 递归法
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        levels = []
        self.helper(root, 0, levels)
        return levels

    def helper(self, node, level, levels):
        if not node:
            return
        if len(levels) == level:
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level + 1, levels)
        self.helper(node.right, level + 1, levels)

Go：

//自己写队列
//I. 按层打印： 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。
//II. 每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) (out [][]int) {
	if root == nil {
		return
	}
	var q []*TreeNode
	q = append(q, root)
	for len(q) > 0 {
		var tmp []int
		l := len(q)
		for i := 0; i < l; i++ {
			node := q[0]
			tmp = append(tmp, node.Val)
			q = q[1:]
			if node.Left != nil {
				q = append(q, node.Left)
			}
			if node.Right != nil {
				q = append(q, node.Right)
			}
		}
		out = append(out, tmp)
	}
	return
}

//使用官方包，解题思想类似
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) (out [][]int) {
	if root == nil {
		return
	}
	queue := list.New()
	queue.PushBack(root)
	for queue.Len() > 0 {
		tmp := make([]int, 0)
		l := queue.Len()
		for i := 0; i < l; i++ {
			node := queue.Remove(queue.Front()).(*TreeNode)
			tmp = append(tmp, node.Val)
			if node.Left != nil {
				queue.PushBack(node.Left)
			} else {
			}
			if node.Right != nil {
				queue.PushBack(node.Right)
			}
		}
		out = append(out, tmp)
	}
	return
}

//官方解法
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
	var ret [][]int
	if root == nil {
		return ret
	}
	q := []*TreeNode{root}
	for i := 0; len(q) > 0; i++ {
		ret = append(ret, []int{})
		var p []*TreeNode
		for j := 0; j < len(q); j++ {
			node := q[j]
			ret[i] = append(ret[i], node.Val)
			if node.Left != nil {
				p = append(p, node.Left)
			}
			if node.Right != nil {
				p = append(p, node.Right)
			}
		}
		q = p
	}
	return ret
}

//递归法
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
	var arr [][]int
	depth := 0
	var order func(root *TreeNode, depth int)
	order = func(root *TreeNode, depth int) {
		if root == nil {
			return
		}
		if len(arr) == depth {
			arr = append(arr, []int{})
		}
		arr[depth] = append(arr[depth], root.Val)
		order(root.Left, depth+1)
		order(root.Right, depth+1)
	}
	order(root, depth)
	return arr
}

二叉树的层序遍历 II

题目链接

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

示例 1：

image-20231126183235038

输入：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

Python：

# 跟上题解法差不多，层序遍历，首部追加
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        out = []
        q = [root]
        while q:
            tmp = []
            l = len(q)
            for i in range(l):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            out = [tmp] + out
        return out

# 先正序再反转
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        out = []
        q = [root]
        while q:
            tmp = []
            l = len(q)
            for i in range(l):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            out.append(tmp)
        out.reverse()
        return out

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        out = []
        q = [root]
        while q:
            tmp = []
            l = len(q)
            for i in range(l):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            out.append(tmp)
        return out[::-1]

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
            if not root:
                return []
            res, queue = [], collections.deque([root])
            while queue:
                tmp = []
                for _ in range(len(queue)):
                    node = queue.popleft()
                    tmp.append(node.val)
                    if node.left:
                        queue.append(node.left)
                    if node.right:
                        queue.append(node.right)
                res.append(tmp)
            res.reverse()
            return res

Go：

//跟上题解法差不多，层序遍历，首部追加
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrderBottom(root *TreeNode) (out [][]int) {
	if root == nil {
		return
	}
	var q []*TreeNode
	q = append(q, root)
	for len(q) > 0 {
		var tmp []int
		l := len(q)
		for i := 0; i < l; i++ {
			node := q[0]
			tmp = append(tmp, node.Val)
			q = q[1:]
			if node.Left != nil {
				q = append(q, node.Left)
			}
			if node.Right != nil {
				q = append(q, node.Right)
			}
		}
		out = append([][]int{tmp}, out...)
	}
	return
}

//正序输出，再反转
func levelOrderBottom(root *TreeNode) [][]int {
    levelOrder := [][]int{}
    if root == nil {
        return levelOrder
    }
    queue := []*TreeNode{}
    queue = append(queue, root)
    for len(queue) > 0 {
        level := []int{}
        size := len(queue)
        for i := 0; i < size; i++ {
            node := queue[0]
            queue = queue[1:]
            level = append(level, node.Val)
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
        levelOrder = append(levelOrder, level)
    }
    for i := 0; i < len(levelOrder) / 2; i++ {
        levelOrder[i], levelOrder[len(levelOrder) - 1 - i] = levelOrder[len(levelOrder) - 1 - i], levelOrder[i]
    }
    return levelOrder
}

二叉树的右视图

题目链接

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

示例 1:

image-20231126190135512

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

示例 2:

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

示例 3:

输入: []
输出: []

提示:

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

Python：

# 层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进及如果数组。
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        res, queue = [], collections.deque([root])
        while queue:
            l = len(queue)
            for i in range(l):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                if i == l - 1:
                    res.append(node.val)
        return res

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        out = []
        q = [root]
        while q:
            l = len(q)
            for i in range(l):
                node = q[i]
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
                if i == l - 1:
                    out.append(node.val)
            q = q[l:]
        return out

# DFS递归遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        out = []

        def dfs(node: TreeNode, level: int) -> None:
            if not node:
                return
            if level == len(out):
                out.append(node.val)
            dfs(node.right, level + 1)
            dfs(node.left, level + 1)

        dfs(root, 0)
        return out

Go：

//BFS,层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进及如果数组。
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func rightSideView(root *TreeNode) (out []int) {
	if root == nil {
		return
	}
	q := []*TreeNode{root}
	for len(q) > 0 {
		l := len(q)
		for i := 0; i < l; i++ {
			node := q[i]
			if node.Left != nil {
				q = append(q, node.Left)
			}
			if node.Right != nil {
				q = append(q, node.Right)
			}
			if i == l-1 {
				out = append(out, node.Val)
			}
		}
		q = q[l:]
	}
	return
}

//递归法，在遍历的过程中，先访问右子树，确保右侧的节点先被处理，然后再访问左子树。这样就能保证每层最右侧的节点被加入到结果列表中。
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func rightSideView(root *TreeNode) (out []int) {
	if root == nil {
		return out
	}

	var dfs func(node *TreeNode, level int)
	dfs = func(node *TreeNode, level int) {
		if node == nil {
			return
		}

		// 每层只保留最右边的节点值
		if level == len(out) {
			out = append(out, node.Val)
		}

		// 先访问右子树，确保右侧的节点先被处理
		dfs(node.Right, level+1)
		dfs(node.Left, level+1)
	}

	dfs(root, 0)
	return out
}

二叉树的层平均值

题目链接

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

示例 1：

image-20231126201131017

输入：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:

image-20231126201124940

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

提示：

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

Python：

#BFS
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if not root:
            return []

        result = []
        queue = deque([root])

        while queue:
            level_size = len(queue)
            level_sum = 0

            for _ in range(level_size):
                node = queue.popleft()
                level_sum += node.val

                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)

            result.append(level_sum / level_size)

        return result

#DFS
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        def dfs(root: TreeNode, level: int):
            if not root:
                return
            if level < len(totals):
                totals[level] += root.val
                counts[level] += 1
            else:
                totals.append(root.val)
                counts.append(1)
            dfs(root.left, level + 1)
            dfs(root.right, level + 1)

        counts = list()
        totals = list()
        dfs(root, 0)
        return [total / count for total, count in zip(totals, counts)]

# DFS
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        result = []

        def dfs(node, level):
            if not node:
                return

            nonlocal result

            if level < len(result):
                result[level][0] += node.val
                result[level][1] += 1
            else:
                result.append([node.val, 1])

            dfs(node.left, level + 1)
            dfs(node.right, level + 1)

        dfs(root, 0)

        return [total / count for total, count in result]

Go：

//BFS
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func averageOfLevels(root *TreeNode) (out []float64) {
	if root == nil {
		return
	}
	q := []*TreeNode{root}
	for len(q) > 0 {
		var tmp []int
		l := len(q)
		for i := 0; i < l; i++ {
			node := q[i]
			tmp = append(tmp, node.Val)
			if node.Left != nil {
				q = append(q, node.Left)
			}
			if node.Right != nil {
				q = append(q, node.Right)
			}
		}
		q = q[l:]
		out = append(out, average(tmp))
	}
	return
}

func average(nums []int) float64 {
	sum := nums[0]
	l := len(nums)
	for i := 1; i < l; i++ {
		sum += nums[i]
	}
	return float64(sum) / float64(l)
}

//BFS
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func averageOfLevels(root *TreeNode) (out []float64) {
	if root == nil {
		return
	}
	q := []*TreeNode{root}
	for len(q) > 0 {
		sum := 0
		l := len(q)
		for i := 0; i < l; i++ {
			node := q[i]
			sum += node.Val
			if node.Left != nil {
				q = append(q, node.Left)
			}
			if node.Right != nil {
				q = append(q, node.Right)
			}
		}
		q = q[l:]
		out = append(out, float64(sum)/float64(l))
	}
	return
}

//DFS
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func averageOfLevels(root *TreeNode) []float64 {
	var result []float64

	var dfs func(node *TreeNode, level int)
	var sum []float64
	var count []int

	dfs = func(node *TreeNode, level int) {
		if node == nil {
			return
		}

		if level < len(sum) {
			sum[level] += float64(node.Val)
			count[level]++
		} else {
			sum = append(sum, float64(node.Val))
			count = append(count, 1)
		}

		dfs(node.Left, level+1)
		dfs(node.Right, level+1)
	}

	dfs(root, 0)

	for i := 0; i < len(sum); i++ {
		result = append(result, sum[i]/float64(count[i]))
	}

	return result
}

//DFS
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
type data struct{ sum, count int }

func averageOfLevels(root *TreeNode) []float64 {
	var levelData []data
    var dfs func(node *TreeNode, level int)
    dfs = func(node *TreeNode, level int) {
        if node == nil {
            return
        }
        if level < len(levelData) {
            levelData[level].sum += node.Val
            levelData[level].count++
        } else {
            levelData = append(levelData, data{node.Val, 1})
        }
        dfs(node.Left, level+1)
        dfs(node.Right, level+1)
    }
    dfs(root, 0)

    averages := make([]float64, len(levelData))
    for i, d := range levelData {
        averages[i] = float64(d.sum) / float64(d.count)
    }
    return averages
}
王翊珩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树前序遍历、中序遍历、后序遍历、层序遍历简单理解，秒懂
qq_49425839的博客
03-19 745
文章开始前，说一句废话：希望大家对所学能认真好好理解，那样才能自己的东西，理解万岁！ 能到这里我相信大家最少知道二叉树是什么东西了吧，那我们直奔主题； 前序遍历，中序遍历，后序遍历，层序遍历到底是什么 一棵二叉树由根结点、左子树和右子树三部分组成，若规定 D、L、R 分别代表遍历根结点、遍历左子树、遍历右子树，我们开始讨论最常见的三种遍历方式 DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ） LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根.
Leetcode刷题(第105题)——从前序与中序遍历序列构造二叉树
weixin_47450807的博客
03-09 464
一、题目 给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。 二、示例 输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] 输出: [3,9,20,null,null,15,7] 输入: preorder = [-1], inorder = [-1] 输出: [-1] 三、解题思路 本题给我们前序遍历和中序遍历，这样我们就可以
【算法】二叉树的前序遍历/中序遍历/后序遍历详解
爱学的萌萌虾
08-18 8066
这个来自leetcode的第144个问题。（中等难度） 问题描述：给定一个二叉树，返回它的 前序 遍历。 相信我们在上学期间（计算机相关专业的）已经学过二叉树，既然决定写这一篇博客，那么就从头开始复习加学习。 二叉树： 定义：二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。或者更通俗点讲： 二叉树（binary tree）是一棵树，其中每个节点都...
[Leetcode]144. 二叉树的前序遍历（扩展：二叉树的中序、后序、层序遍历）
tc979907461的博客
03-23 431
144. 二叉树的前序遍历 给定一个二叉树，返回它的 前序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 思路 1.前序遍历的规律为根节点-左节点-右节点，使用的是深度优先遍历，即先获取到某个确定的子节点，再返回根节点到达另一个子节点，知道遍历完成。使用递归法根据根节点–>左子树–>右子树...
【二叉树初阶】前中后序遍历+层序遍历+基础习题
weixin_46016019的博客
04-19 5395
图解二叉树前序、中序、后序、层序遍历详解，以及基础习题解析，
【算法】二叉树遍历算法总结：前序中序后序遍历
蛮三刀酱
02-22 4864
前言 二叉树遍历是非常经典的算法题，也是二叉树的一道基础算法题。 但是在平常的笔试面试中，其出现的频率其实并不是特别的高，我推测是这种题目相对来说比较基础，算是一个基础知识点。 比如剑指offer中出现的后序遍历题目，是给出一个数字序列，让你判断是不是平衡二叉树后序遍历序列，这样出题的难度比直接让你写后序遍历难很多。 但是，二叉树遍历容易吗？在递归方法下，前中后序遍历都是一个思路，理解起来也比较...
二叉树的三种遍历方式：前序遍历、中序遍历和后序遍历
Azahaxia的博客
06-15 3073
二叉树的三种遍历方式
LeetCode二叉树的前序、中序、后序遍历（递归实现）
码上暴富
10-08 711
本文用递归算法实现二叉树的前序、中序和后序遍历，提供Java版的基本模板，在模板上稍作修改，即可解决LeetCode144. Binary Tree Preorder Traversal（二叉树前序遍历），94. Binary Tree Inorder Traversal（二叉树中序遍历），145. Binary Tree Postorder Traversal（二叉树后序遍历）。
Java版二叉树的前序遍历查找、中序遍历查找和后序遍历查找
qq_37837621的博客
02-19 1870
文章收藏的好句子：任何挫折，如果无法彻底击败你，那一定会使你更强。目录1、二叉树的节点查找 1、1 前序遍历查找 1、2 中序遍历查找 1、3 后序遍历查找1、二叉...
LeetCode105——从前序与中序遍历序列构造二叉树
清风阁
11-17 807
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/ 题目描述： 知识点：根据前序与中序遍历重建二叉树 思路：前序遍历决...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
LeetCode–144,94,145,102 二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列)
12-21
二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列）1. 二叉树的前序遍历1.1 题目描述1.2 题目分析1.3 Python实现2. 二叉树的中序遍历2.1 题目描述2.2 题目分析2.3 Python实现3. 二叉树的后序遍历2.1 题目...
【LeetCode】【树】106. 从中序与后序遍历序列构造二叉树
12-20
从中序与后序遍历序列构造二叉树 1 题目地址 https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/ 2 题目描述 根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你...
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
10-18
主要介绍了PHP基于非递归算法实现先序、中序及后序遍历二叉树操作,结合实例形式分析了php采用非递归算法对二叉树进行先序、中序及后序遍历操作的原理与具体实现技巧,需要的朋友可以参考下
【力扣刷题 动态规划】LeetCode 139 单词拆分、LeetCode 300 最长递增子序列 ✌
最新发布
Hou_lang_LJ的博客
06-02 976
🐧①LeetCode 139 单词拆分、LeetCode 300 最长递增子序列 🖊😄✌
leetcode5 最长回文子串
2402_84062759的博客
06-02 414
给你一个字符串s，找到s中最长的 回文 子串。"bab""aba" 同样是符合题意的答案。
代码随想录训练营Day56：Leetcode647、516
maybeyaluokenai的博客
05-31 213
Leetcode647、516
159.二叉树：二叉树的层平均值（力扣）
weixin_63779802的博客
05-31 356
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
Golang | Leetcode Golang题解之第122题买卖股票的最佳时机II
weixin_66442839的博客
05-31 324
Golang | Leetcode Golang题解之第122题买卖股票的最佳时机II
二叉树的后序遍历c++
05-27
二叉树的后序遍历可以使用递归或者非递归的方式实现。下面是使用递归的C++代码实现： ``` void postorderTraversal(TreeNode* root) { if (root == nullptr) { return; } postorderTraversal(root->left); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王翊珩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值