# Solving Leetcode Interviews in Seconds with AI: Binary Tree Right Side View


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "199" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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] Explanation:   Example 2:  Input: root = [1,2,3,4,null,null,null,5] Output: [1,3,4,5] Explanation:   Example 3:  Input: root = [1,null,3] Output: [1,3]  Example 4:  Input: root = [] Output: []    Constraints:  The number of nodes in the tree is in the range [0, 100]. -100 <= Node.val <= 100  

	# Explanation
	Here's a solution to the problem of finding the right side view of a binary tree:

*   **Level-Order Traversal:** Perform a level-order (breadth-first) traversal of the tree.
*   **Rightmost Node:** For each level, the rightmost node encountered during the traversal is the one visible from the right side. Store the value of this node.
*   **Result:** Collect the values of the rightmost nodes from each level in a list.

*   **Time Complexity:** O(N), where N is the number of nodes in the tree.
*   **Space Complexity:** O(W), where W is the maximum width of the tree (worst case O(N) if the tree is skewed).

	
	# Code
	```python
	from collections import deque

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def rightSideView(root):
    """
    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.
    """
    if not root:
        return []

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

    while queue:
        level_size = len(queue)

        for i in range(level_size):
            node = queue.popleft()

            if i == level_size - 1:
                result.append(node.val)

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

    return result
	```