Binary Tree Right Side View

Problem

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

Example 1:

复制代码
Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

Example 2:

复制代码
Input: root = [1,null,3]
Output: [1,3]

Example 3:

复制代码
Input: root = []
Output: []

Intuition

The task is to imagine standing on the right side of a binary tree and returning the values of the nodes visible from that perspective. The intuition is to perform a level order traversal of the binary tree and, for each level, only consider the value of the rightmost node, as that would be the one visible from the right side.

Approach

Initialization:

Check if the root is None. If so, return an empty list since there are no nodes to traverse.

Breadth-First Search (BFS):

Use a queue (in this case, a deque) to perform a breadth-first traversal of the binary tree.

Initialize the queue with the root node.

Right Side View:

While the queue is not empty:

For each level, create a temporary list (temp) to store the values of nodes.

Process all nodes at the current level:

Pop the front node from the queue.

Enqueue its left and right children (if any).

Append the value of the current node to the temp list.

If the temp list is not empty, append the value of the rightmost node to the final result (stack).

Return Result:

Return the final result, which is a list of values representing the nodes visible from the right side.

Complexity

  • Time complexity:

The time complexity is O(n), where n is the number of nodes in the binary tree. Each node is visited exactly once during the traversal.

  • Space complexity:

The space complexity is O(m), where m is the maximum number of nodes at any level in the binary tree. In the worst case, the maximum number of nodes at any level is the number of leaf nodes, which is at most n/2 in a balanced binary tree. Therefore, the space complexity is O(n/2), which simplifies to O(n) in big-O notation. This is because the space required to store nodes at any level scales with the number of nodes in the tree.

Code

复制代码
# 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 []

        stack = [root.val]
        q = deque([root])
        while q:
            temp = []
            for _ in range(len(q)):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                    temp.append(node.left.val)
                if node.right:
                    q.append(node.right)
                    temp.append(node.right.val)

            if temp:
                stack.append(temp[-1])

        return stack
相关推荐
IT信息技术学习圈40 分钟前
算法核心知识复习:排序算法对比 + 递归与递推深度解析(根据GESP四级题目总结)
算法·排序算法
愚润求学1 小时前
【动态规划】01背包问题
c++·算法·leetcode·动态规划
会唱歌的小黄李1 小时前
【算法】贪心算法入门
算法·贪心算法
轻语呢喃2 小时前
每日LeetCode : 两数相加--链表操作与进位的经典处理
javascript·算法
钢铁男儿2 小时前
C# 接口(接口可以继承接口)
java·算法·c#
zl_vslam3 小时前
SLAM中的非线性优化-2D图优化之激光SLAM cartographer前端匹配(十七)
前端·人工智能·算法
dying_man4 小时前
LeetCode--44.通配符匹配
算法·leetcode
Paper Clouds4 小时前
代码随想录|图论|15并查集理论基础
数据结构·算法·leetcode·深度优先·图论
Paper Clouds4 小时前
代码随想录|图论|14有向图的完全可达性
数据结构·算法·深度优先·图论·宽度优先
遇见尚硅谷5 小时前
C语言:游戏代码分享
c语言·开发语言·算法·游戏