Aditya Negi

Tree Data Structure: Basics

Aditya Negi — Thu, 02 Oct 2025 00:00:00 GMT

Introduction to Trees

When learning data structures, trees mark a turning point. They move us beyond linear structures like arrays and linked lists, into the world of hierarchical data — a structure where relationships matter as much as values.

Why Trees Matter in Computer Science

Trees appear everywhere in computing:

Hierarchical Data Representation
- File systems (folders containing files and subfolders).
- XML/HTML documents (DOM tree).
- Organization charts.
Databases
- B-trees and B+ trees form the backbone of most relational database indexes.
- Binary search trees (BSTs) for efficient searching.
Compilers & Parsing
- Abstract Syntax Trees (ASTs) represent the structure of source code.
Artificial Intelligence
- Decision trees and game trees power algorithms for planning and search.
Networking & Operating Systems
- Routing tables, memory allocation trees, process hierarchies.

In short, trees help us represent data with parent-child relationships efficiently.

Where You’ll Encounter Trees

If you’re preparing for technical interviews or doing competitive programming, trees are unavoidable. Expect to see them in:

LeetCode / Codeforces / HackerRank problems.
Google, Meta, Amazon interviews (common focus on tree traversals, Lowest Common Ancestor, diameter, etc.).
Competitive contests requiring efficient data queries (segment trees, Fenwick trees).

Mastering trees builds intuition that directly transfers to graph algorithms, since a tree is just a special type of graph.

A Quick Mental Model

Here’s a simple way to think about trees in the broader landscape of data structures:

Linked List → A linear chain of nodes (like a train).
Tree → A branching structure of nodes (like a family tree).
Graph → A general network of nodes and edges (like a city map).

Basic Terminology in Trees

Before diving into traversals or algorithms, it’s important to understand the core terminology of trees. These definitions will appear again and again, both in theory and in interview problems.

Node

A node is the basic building block of a tree.

Each node typically stores a value (or data).
It may also have pointers (or references) to its children.

Example in code (binary tree node in TypeScript):

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;

  constructor(val: number) {
    this.val = val;
    this.left = null;
    this.right = null;
  }
}

Root

The root is the topmost node in a tree.
It has no parent.
Every other node is a descendant of the root.

:::viber Think of the C drive in your computer — all files and folders branch out from it. :::

Parent, Child, and Sibling

Parent → is a node with one or more child nodes.
Child → is a node that descends from a parent.
Siblings → are nodes that share the same parent.

:::viber{align="right"} Example: In a family tree, you and your brother are siblings because you share the same parent. :::

Leaf

          A         <- Root
        /   \
       B     C     <- B and C are children of A (A is their parent)
      / \     \
     D   E     F <- D, E, F are leaf nodes (no children)

A leaf is a node that has no children.
Also called a terminal node.

:::viber In a file system analogy, a file is usually a leaf, while folders are internal nodes. :::

Height, Depth, and Level

These terms are often confused, so let’s clarify:

Depth of a node → Distance from the root to that node (root has depth 0).
Height of a node → Longest path from that node to a leaf.
Height of Tree → Height of the root node.
Level of a node → Depth + 1 (so the root is at level 1).

        A (root)
       / \
      B   C
     / \
    D   E

Depth of A = 0

Depth of B = 1

Height of B = 1 (longest path to D or E)

Height of A = 2

Level of C = 2

Subtree

A subtree is simply a tree within a tree.
Every node defines the root of its own subtree.

For example, in the above diagram, the node B and its children (D, E) form a subtree.

:::viber Subtrees are essential when solving recursive tree problems, because you often break a tree down into its left and right subtrees. :::

Types of Trees

Trees can take many forms depending on how many children nodes each node has and how balanced the tree is. Understanding the different types of trees helps in choosing the right data structure for a problem.

General Tree

A general tree is a tree where a node can have any number of children.

Node A has three children: B, C, and D.
Node C has two children: E and F.
There is no restriction on the number of children per node.

Binary Tree

A binary tree is a tree where each node has at most 2 children, commonly referred to as left and right.

Node A has two children: B and C.
Node B has two children: D and E.
Node C has no children.

Full / Complete / Perfect Binary Trees

Full Binary Tree

Every node has 0 or 2 children.

C is a leaf, B has 2 children → satisfies full binary tree properties.

Complete Binary Tree

All levels are completely filled except possibly the last, which is filled from left to right.

Level 3 is partially filled, but nodes are filled left to right → complete binary tree.

Perfect Binary Tree

All internal nodes have 2 children and all leaves are at the same level.


        A
       / \
      B   C
     / \ / \
    D  E F  G

Fully balanced, no missing nodes → perfect binary tree.

Skewed Tree

A skewed tree is a tree where all nodes have only one child.

Left-skewed: each node has only a left child.

Left-Skewed
    A
   /
  B
 /
C

Right-skewed: each node has only a right child.

Right-Skewed
A
 \
  B
   \
    C

Skewed trees behave like linked lists.
Traversals have worst-case time complexity of O(n).

Tree Data Structure: Traversals

Aditya Negi — Fri, 03 Oct 2025 00:00:00 GMT

Tree Traversals

Tree traversal means visiting each node in a specific order.

Two main categories:

Depth-First Search (DFS) → Preorder, Inorder, Postorder
Breadth-First Search (BFS) → Level-order

We’ll use this basic class written in Python for examples:

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

Preorder Traversal (Root → Left → Right)

       A
      / \
     B   C
    / \
   D   E

Preorder: A → B → D → E → C

# Recursive
def preorder(node):
    if not node:
        return
    print(node.val)      # Root
    preorder(node.left)  # Left
    preorder(node.right) # Right

# Iterative
def preorder_iter(root):
    if not root:
        return
    stack = [root]
    while stack:
        node = stack.pop()
        print(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)

Inorder Traversal (Left → Root → Right)

       A
      / \
     B   C
    / \
   D   E

Inorder: D → B → E → A → C


# Recursive
def preorder(node):
    if not node:
        return
    print(node.val)      # Root
    preorder(node.left)  # Left
    preorder(node.right) # Right

# Iterative
def preorder_iter(root):
    if not root:
        return
    stack = [root]
    while stack:
        node = stack.pop()
        print(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)

Postorder Traversal (Left → Right → Root)


       A
      / \
     B   C
    / \
   D   E

Postorder: D → E → B → C → A

# Recursive
def postorder(node):
    if not node:
        return
    postorder(node.left)   # Left
    postorder(node.right)  # Right
    print(node.val)        # Root

# Iterative
def postorder_iter(root):
    if not root:
        return
    stack, out = [root], []
    while stack:
        node = stack.pop()
        out.append(node.val)
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)
    for val in reversed(out):
        print(val)

Level Order Traversal


       A
      / \
     B   C
    / \
   D   E

Level Order: A → B → C → D → E

from collections import deque

def level_order(root):
    if not root:
        return
    q = deque([root])
    while q:
        node = q.popleft()
        print(node.val)
        if node.left:
            q.append(node.left)
        if node.right:
            q.append(node.right)

Grouped Level Order

Visit nodes level by level, left → right.
Group nodes per level.


        A
       / \
      B   C
     / \   \
    D   E   F

Level 1: [A]             -> Start with root
Level 2: [B, C]          -> Children of A
Level 3: [D, E, F]       -> Children of B and C

Output: [[A], [B, C], [D, E, F]]

def level_order_grouped(root):
    res = []
    if not root:
        return res
    q = deque([root])
    while q:
        size = len(q)
        level = []
        for _ in range(size):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        res.append(level)
    return res

Zigzag Level Order

Visit nodes level by level, but alternate the order each level: left→right, right→left, left→right..


        A
       / \
      B   C
     / \   \
    D   E   F

Level 1 (Left→Right):  [A]
Level 2 (Right→Left):  [C, B]
Level 3 (Left→Right):  [D, E, F]

Output: [[A], [C, B], [D, E, F]]

def zigzag_level_order(root):
    res = []
    if not root:
        return res
    q = deque([root])
    left_to_right = True
    while q:
        size = len(q)
        level = deque()
        for _ in range(size):
            node = q.popleft()
            if left_to_right:
                level.append(node.val)
            else:
                level.appendleft(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        res.append(list(level))
        left_to_right = not left_to_right
    return res

Leetcode 226: Inverting a Binary Tree

Aditya Negi — Sat, 04 Oct 2025 00:00:00 GMT

Problem Statement

Given the root of a binary tree, invert the tree, and return its root.

Link To the Problem

Intuition

A binary tree is a tree where each node has at most 2 children, commonly referred to as left and right. Inverting a binary tree means swapping the left and right subtrees of every node.

Approach

We can solve this problem recursively or iteratively:

Recursive Approach (DFS):
- If the current node is None, return None.
- Swap the left and right children recursively:
- Set the left child to the result of inverting the original right subtree.
- Set the right child to the result of inverting the original left subtree.
- Return the current node.
Iterative Approach (BFS):
- Use a queue to perform level-order traversal.
- For each node in the queue, swap its left and right children.
- Add non-null children to the queue for further processing.

Complexity

Time complexity: O(n), where n is the number of nodes in the tree. Each node is visited exactly once.
Space complexity:
- Recursive approach: O(h) due to the recursion stack, where h is the height of the tree.
- Iterative approach: O(n) in the worst case for the queue.

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:

    # Recursive Implementation (DFS)
    def invert_tree_recursively(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root :
            return 

        # swap the nodes in place
        root.left,root.right = self.invert_tree_recursively(root.right),self.invert_tree_recursively(root.left)

        return root 

    # Iterative Implementation (BFS)
     def invert_tree_iteratively(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None

        queue = deque([root])

        while queue:
            node = queue.popleft()
            
            # swap the nodes in place
            node.left, node.right = node.right, node.left
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        return root

Leetcode 100: Check if two binary tree are the same

Aditya Negi — Sun, 05 Oct 2025 00:00:00 GMT

Problem Statement

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

Link To the Problem

Intuition

When comparing two binary trees, the key is to check structure and values at the same time.

If both nodes are None, they are identical in that position.
If one node is None but the other isn’t, the trees differ.
If both nodes exist, their values must be equal, and their left and right subtrees must also be the same.

Approach

We perform a recursive check:

Base case 1: If both nodes are None, return True.
Base case 2: If only one of them is None, return False.
Base case 3: If the values don’t match, return False.
Recursive step: Check if both left subtrees and right subtrees are identical.

This ensures both the structure and values of the trees are the same.

Complexity

Time complexity: Each node is visited exactly once, so the complexity is O(n) where n is the number of nodes (minimum of the two trees).
Space complexity: The recursion depth depends on the height of the tree. In the worst case (skewed tree), the depth is O(n). In the best case (balanced tree), it’s O(log n). So, space complexity is O(h) where h is the height of 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 is_same_tree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:

        if p is None and q is None :
            return True

        if p is None or q is None :
            return False

        if p.val != q.val :
            return False

        return self.is_same_tree(p.left,q.left) and self.is_same_tree(p.right,q.right)

Leetcode 572: Subtree of Another Tree

Aditya Negi — Sun, 12 Oct 2025 00:00:00 GMT

Problem Statement

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.

A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.

Link To the Problem

Intuition

A binary tree is composed of nodes, each having up to two children. To determine if one tree (subRoot) is a subtree of another (root), we need to check whether subRoot appears exactly somewhere inside root.

That means:

There must exist a node in root such that the subtree rooted at that node is identical to subRoot.
Two trees are identical if their node values and structure match perfectly.

Approach

We can solve this problem using a recursive approach:

Base idea:

Traverse the main tree (root) node by node.
At each node, check if the subtree starting there matches subRoot.

Helper function (compare)

Compares two trees for equality.
Returns True only if both are None or if their values and corresponding children are identical.

Recursive traversal (is_subtree)

If the current subtree of root matches subRoot, return True.
Otherwise, recursively check the left and right subtrees of root.
If no match is found, return False.

This approach effectively checks all possible subtree roots in the main tree.

Complexity

Time complexity: O(m * n), where m = number of nodes in root and n = number of nodes in subRoot. For each node in root , we may compare upto n nodes in subRoot.
Space complexity: O(h) due to the recursion stack, where h is the height of 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 compare(self,node1,node2) :
        if not node1 and not node2 :
            return True

        if not node1 or not node2 :
            return False
        
        if node1.val != node2.val :
            return False

        return self.compare(node1.left,node2.left) and self.compare(node1.right,node2.right)

    def is_subtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        
        if self.compare(root,subRoot) :
            return True

        if root.left and self.is_subtree(root.left,subRoot):
            return True

        if root.right and self.is_subtree(root.right,subRoot) :
            return True

        return False

Leetcode 235: Lowest Common Ancestor of a Binary Search Tree

Aditya Negi — Mon, 13 Oct 2025 00:00:00 GMT

Problem Statement

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.

The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).

Link To the Problem

Intuition

When both target nodes p and q lie on the same side of the current node (either both in the left or both in the right subtree), the Lowest Common Ancestor (LCA) must also be on that side.

However, when they diverge — one node is on the left and the other on the right (or one is equal to the current node) — the current node itself becomes their lowest common ancestor.

Approach

Start from the root node.
If both p and q have values smaller than root.val, the LCA must be in the left subtree, so recurse left.
If both p and q have values greater than root.val, the LCA must be in the right subtree, so recurse right.
If the values diverge (i.e., one on each side, or one equals the root), then the current root is the LCA.

This logic works because of the Binary Search Tree (BST) property — left subtree values < root < right subtree values.

Complexity

Time complexity: O(h), where h is where is the height of the tree.
- In a balanced BST, h=log(n),
- In the worst case (skewed tree), h=n
Space complexity:
- Recursive approach: O(h) due to the recursion stack, where h is the height of the tree.

Code

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # Base case: if the tree is empty
        if not root:
            return None

        # If both p and q are smaller, LCA is in the left subtree
        if p.val < root.val and q.val < root.val:
            return self.lowestCommonAncestor(root.left, p, q)

        # If both p and q are greater, LCA is in the right subtree
        elif p.val > root.val and q.val > root.val:
            return self.lowestCommonAncestor(root.right, p, q)

        # Otherwise, root is the split point — the LCA
        else:
            return root

Leetcode 199: Binary Tree Right Side View

Aditya Negi — Tue, 14 Oct 2025 00:00:00 GMT

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.

Link To the Problem

Intuition

When viewing a binary tree from the right side, at each level of the tree, we only see the rightmost node. So, if we traverse the tree level by level (using Breadth-First Search), the last node encountered at each level will be visible from the right side.

Approach

Use a queue (deque) to perform a level-order traversal (BFS).
For each level:
- Process all nodes currently in the queue (those belonging to the same level).
- Keep track of the last node’s value encountered at this level — that node will be visible from the right side.
Add the value of the rightmost node from each level to the result list.
Return the result list after the traversal is complete.

Complexity

Time complexity: Each node is visited exactly once, so the complexity is O(n) where n is the number of nodes
Space complexity: O(w) where w is the maximum width of the tree (worst-case O(n) for a complete tree), due to the queue used in BFS.

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

from collections import deque

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        q = deque([root])
        res = []
        
        while q:
            n = len(q)
            for i in range(n):
                node = q.popleft()
                # If it's the last node in this level, add it to the result
                if i == n - 1:
                    res.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
        
        return res

Leetcode 1448: Count Good Nodes in Binary Tree

Aditya Negi — Thu, 23 Oct 2025 00:00:00 GMT

Problem Statement

Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.

Return the number of good nodes in the binary tree.

Link To the Problem

Intuition

A node is considered good if, on the path from the root to that node, there are no nodes with a greater value than it.

So, as we traverse the tree, we can keep track of the maximum value encountered so far along the path.
If the current node’s value is greater than or equal to this maximum, we count it as a “good” node.

Approach

We can solve this problem using Depth-First Search (DFS).

Start from the root and initialize the max_until_now as negative infinity.
At each node:
- If node.val >= max_until_now, it’s a good node.
- Update the maximum for the next recursive calls as max(max_until_now, node.val).
Recursively count the number of good nodes in the left and right subtrees.
The total number of good nodes is the sum of:
- 1 (if the current node is good)
- number of good nodes in the left subtree
- number of good nodes in the right subtree.

Complexity

Time Complexity:
O(n), since we visit every node exactly once.
Space Complexity:
O(h), where h is the height of the tree (due to recursion stack).
- Worst case (skewed tree): O(n)
- Best case (balanced tree): O(\log n)

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 goodNodes(self, root: TreeNode) -> int:

        def dfs(node, max_until_now):
            if not node:
                return 0

            res = 0
            if node.val >= max_until_now:
                res += 1

            new_max = max(max_until_now, node.val)
            res += dfs(node.left, new_max)
            res += dfs(node.right, new_max)

            return res

        return dfs(root, -float("inf"))