Chillymosh's Blog

Binary Search Trees: Fast Lookups and Dynamic Data

Sun, 03 Aug 2025 07:10:00 GMT

import { Aside, Collapse, MdxRepl, Tabs, TabItem } from "astro-pure/user" import BSTExample from "binarytree-BST.svg"; import BSTExample2 from "binarytree-BST2.svg"; import NodeCycler from '@/components/NodeCycler2.astro';

Binary Search Trees (BSTs) are one of the most important and widely used types of binary trees. By maintaining a sorted structure, BSTs provide efficient searching, insertion, and deletion operations at the heart of sets, maps, databases, and more.

In this post, we'll cover:

What makes a tree a BST
Search, insertion, and deletion algorithms
Average vs worst-case performance
Common pitfalls and balancing needs
Practical code examples

What is a Binary Search Tree?

A Binary Search Tree (also called an ordered or sorted binary tree) is a tree-based data structure where each node follows a strict organising rule: its value is greater than everything in its left subtree and less than everything in its right subtree. This ordering keeps the tree's data sorted as you insert or remove nodes, which enables fast searching, insertion, and deletion. This is often much more efficient than a simple list.

Imagine a perfectly organised filing system where every bit of data knows exactly where it belongs. The performance of searching, inserting, or deleting all hinges on the tree's height. Shorter, well-balanced trees deliver the best performance.

Left side: All values smaller than the current node
Right side: All values larger than the current node
Universal rule: This pattern holds true at every single node in the tree

This simple principle makes sure your data stays sorted, which makes searching incredibly fast.

Search

How to efficiently find a value in a BST:

Start at the root.
If the value equals the root, you're done.
If less, search the left subtree; if greater, search the right.
Repeat until found or you hit a leaf. If the latter then you would return None.

The time complexity for searching a BST for a value is O(h) where h is the height of the tree. If the tree is unbalanced then the height of the tree often becomes larger than it needs to be, which will cause searches to take longer.

Recursive

Iterative

Insert

How to insert a new value while maintaining the BST property:

Start at the root.
If less, go left; if greater, go right.
Repeat until you find a None/null spot.
Insert the new node there.

Recursive

if (data < node.val) {
    node.left = insert(node.left, data);
} else if (data > node.val) {
    node.right = insert(node.right, data);
}

return node;

}

</TabItem>
<TabItem label="C#">
```c#
public Node Insert(Node node, int data)
{
    if (node == null)
    {
        return new Node(data);
    }

    if (data < node.val)
    {
        node.left = Insert(node.left, data);
    }
    else if (data > node.val)
    {
        node.right = Insert(node.right, data);
    }

    return node;
}

if (data < node->val) {
    node->left = insert(node->left, data);
} else if (data > node->val) {
    node->right = insert(node->right, data);
}

return node;

}

</TabItem>
<TabItem label="C">
```c
Node* insert(Node* node, int key) {
    if (node == NULL) {
        Node* new_node = (Node*)malloc(sizeof(Node));
        new_node->val = key;
        new_node->left = new_node->right = NULL;
        return new_node;
    }

    if (key < node->val) {
        node->left = insert(node->left, key);
    } else if (key > node->val) {
        node->right = insert(node->right, key);
    }

    return node;
}

Iterative

Iterative BST insertion is possible but less common in practice. Recursive methods are clearer for most cases.

Iteration is used when the application is performance critical or the Binary Tree is deep enough it could cause a stack overflow.

current = root
while True:
    if data < current.val:
        if current.left is None:
            current.left = Node(data)
            break
        else:
            current = current.left
    elif data > current.val:
        if current.right is None:
            current.right = Node(data)
            break
        else:
            current = current.right
    else:
        break 

return root

</TabItem>
<TabItem label="Javascript">
```js
function insert(root, val) {
    if (root === null) {
        return new Node(val);
    }
    
    let current = root;
    while (true) {
        if (val < current.val) {
            if (current.left === null) {
                current.left = new Node(val);
                break;
            }
            current = current.left;
        } else if (val > current.val) {
            if (current.right === null) {
                current.right = new Node(val);
                break;
            }
            current = current.right;
        } else {
            break;
        }
    }
    return root;
}

current := root
for {
    if val < current.Val {
        if current.Left == nil {
            current.Left = &Node{Val: val}
            break
        }
        current = current.Left
    } else if val > current.Val {
        if current.Right == nil {
            current.Right = &Node{Val: val}
            break
        }
        current = current.Right
    } else {
        break
    }
}
return root

}

</TabItem>
<TabItem label="Java">
```java
public Node insert(Node root, int val) {
    if (root == null) {
        return new Node(val);
    }
    
    Node current = root;
    while (true) {
        if (val < current.val) {
            if (current.left == null) {
                current.left = new Node(val);
                break;
            }
            current = current.left;
        } else if (val > current.val) {
            if (current.right == null) {
                current.right = new Node(val);
                break;
            }
            current = current.right;
        } else {
            break;
        }
    }
    return root;
}

Node current = root;
while (true) {
    if (val < current.val) {
        if (current.left == null) {
            current.left = new Node(val);
            break;
        }
        current = current.left;
    } else if (val > current.val) {
        if (current.right == null) {
            current.right = new Node(val);
            break;
        }
        current = current.right;
    } else {
        break;
    }
}
return root;

}

</TabItem>
<TabItem label="C++">
```cpp
Node* insert(Node* root, int val) {
    if (root == nullptr) {
        return new Node(val);
    }
    
    Node* current = root;
    while (true) {
        if (val < current->val) {
            if (current->left == nullptr) {
                current->left = new Node(val);
                break;
            }
            current = current->left;
        } else if (val > current->val) {
            if (current->right == nullptr) {
                current->right = new Node(val);
                break;
            }
            current = current->right;
        } else {
            break;
        }
    }
    return root;
}

Node* current = root;
while (1) {
    if (val < current->val) {
        if (current->left == NULL) {
            current->left = createNode(val);
            break;
        }
        current = current->left;
    } else if (val > current->val) {
        if (current->right == NULL) {
            current->right = createNode(val);
            break;
        }
        current = current->right;
    } else {
        break;
    }
}
return root;

}

</TabItem>
<TabItem label="Rust">
```rs
pub fn insert(mut root: Option<Box<Node>>, val: i32) -> Option<Box<Node>> {
    let mut curr = &mut root;
    loop {
        match curr {
            None => {
                *curr = Some(Box::new(Node::new(val)));
                break;
            }
            Some(node) => {
                if val < node.val {
                    curr = &mut node.left;
                } else if val > node.val {
                    curr = &mut node.right;
                } else {
                    break;
                }
            }
        }
    }
    root
}

Delete

Deleting a value from a BST is more involved:

If the node is a leaf: remove it.
If it has one child: replace it with its child.
If it has two children then you have two options:
- Replace it with its in-order successor (smallest node in right subtree)
- Replace it with its in-order predecessor (largest node in left subtree)
- After either of the above, remove the target node.

Deleting the root 15

Find the next in-order successor (18)
The leaf of 18 is now the root, replacing 15.
If we wanted the in-order predecessor then the leaf 9 would replace 15. </ Aside>

Recursive

These examples cover every deletion case in a BST and use small, purpose built helpers for clarity. In real world code you can simplify further.

e.g. merge find_successor and find_predecessor into one function, or even inline that logic directly into your delete function if you don't need the separate helpers.

def find_predecessor(node): current = node.left while current.right is not None: current = current.right return current

def delete(root, target, use_successor=True): if root is None: return None

if target < root.val:
    root.left = delete(root.left, target, use_successor)
elif target > root.val:
    root.right = delete(root.right, target, use_successor)
elif root.left is None and root.right is None:
    return None
elif root.left is None:
    return root.right
elif root.right is None:
    return root.left
else:
    if use_successor:
        replacement = find_successor(root)
        root.val = replacement.val
        root.right = delete(root.right, replacement.val, use_successor)
    else:
        replacement = find_predecessor(root)
        root.val = replacement.val
        root.left = delete(root.left, replacement.val, use_successor)

return root

</TabItem>
<TabItem label="Javascript">
```js
function findSuccessor(node) {
  let current = node.right;
  while (current.left !== null) {
    current = current.left;
  }
  return current;
}

function findPredecessor(node) {
  let current = node.left;
  while (current.right !== null) {
    current = current.right;
  }
  return current;
}

function deleteNode(root, target, useSuccessor = true) {
  if (root === null) {
    return null;
  }

  if (target < root.val) {
    root.left = deleteNode(root.left, target, useSuccessor);
    return root;
  }
  if (target > root.val) {
    root.right = deleteNode(root.right, target, useSuccessor);
    return root;
  }

  switch (true) {
    case (root.left === null && root.right === null):
      return null;

    case (root.left === null):
      return root.right;

    case (root.right === null):
      return root.left;

    default:
      if (useSuccessor) {
        const replacement = findSuccessor(root);
        root.val = replacement.val;
        root.right = deleteNode(root.right, replacement.val, true);
      } else {
        const replacement = findPredecessor(root);
        root.val = replacement.val;
        root.left = deleteNode(root.left, replacement.val, false);
      }
      return root;
  }
}

func findPredecessor(node *Node) *Node { current := node.Left for current.Right != nil { current = current.Right } return current }

func deleteNode(root *Node, target int, useSuccessor bool) *Node { if root == nil { return nil } if target < root.Val { root.Left = deleteNode(root.Left, target, useSuccessor) } else if target > root.Val { root.Right = deleteNode(root.Right, target, useSuccessor) } else { switch { case root.Left == nil && root.Right == nil: return nil case root.Left == nil: return root.Right case root.Right == nil: return root.Left default: if useSuccessor { repl := findSuccessor(root) root.Val = repl.Val root.Right = deleteNode(root.Right, repl.Val, useSuccessor) } else { repl := findPredecessor(root) root.Val = repl.Val root.Left = deleteNode(root.Left, repl.Val, useSuccessor) } } } return root }

</TabItem>
<TabItem label="Java">
```java
public Node findSuccessor(Node node) {
    Node current = node.right;
    while (current.left != null) {
        current = current.left;
    }
    return current;
}

public Node findPredecessor(Node node) {
    Node current = node.left;
    while (current.right != null) {
        current = current.right;
    }
    return current;
}

public Node deleteNode(Node root, int target, boolean useSuccessor) {
    if (root == null) {
        return root;
    }
    if (target < root.val) {
        root.left = deleteNode(root.left, target, useSuccessor);
    } else if (target > root.val) {
        root.right = deleteNode(root.right, target, useSuccessor);
    } else if (root.left == null && root.right == null) {
        return null;
    } else if (root.left == null) {
        return root.right;
    } else if (root.right == null) {
        return root.left;
    } else {
        if (useSuccessor) {
            Node replacement = findSuccessor(root);
            root.val = replacement.val;
            root.right = deleteNode(root.right, replacement.val, useSuccessor);
        } else {
            Node replacement = findPredecessor(root);
            root.val = replacement.val;
            root.left = deleteNode(root.left, replacement.val, useSuccessor);
        }
    }
    return root;
}

public Node FindPredecessor(Node node) { var current = node.left; while (current.right != null) { current = current.right; } return current; }

public Node DeleteNode(Node root, int target, bool useSuccessor = true) { if (root == null) { return root; }

if (target < root.val) {
    root.left = DeleteNode(root.left, target, useSuccessor);
} else if (target > root.val) {
    root.right = DeleteNode(root.right, target, useSuccessor);
} else if (root.left == null && root.right == null) {
    return null;
} else if (root.left == null) {
    return root.right;
} else if (root.right == null) {
    return root.left;
} else {
    if (useSuccessor) {
        var replacement = FindSuccessor(root);
        root.val = replacement.val;
        root.right = DeleteNode(root.right, replacement.val, useSuccessor);
    } else {
        var replacement = FindPredecessor(root);
        root.val = replacement.val;
        root.left = DeleteNode(root.left, replacement.val, useSuccessor);
    }
}
return root;

}

</TabItem>
<TabItem label="C++">
```cpp
Node* findSuccessor(Node* node) {
    auto current = node->right;
    while (current->left) {
        current = current->left;
    }
    return current;
}

Node* findPredecessor(Node* node) {
    auto current = node->left;
    while (current->right) {
        current = current->right;
    }
    return current;
}

Node* deleteNode(Node* root, int target, bool useSuccessor = true) {
    if (!root) {
        return root;
    }

    if (target < root->val) {
        root->left = deleteNode(root->left, target, useSuccessor);
    } else if (target > root->val) {
        root->right = deleteNode(root->right, target, useSuccessor);
    } else if (!root->left && !root->right) {
        delete root;
        return nullptr;
    } else if (!root->left) {
        auto tmp = root->right;
        delete root;
        return tmp;
    } else if (!root->right) {
        auto tmp = root->left;
        delete root;
        return tmp;
    } else {
        if (useSuccessor) {
            auto replacement = findSuccessor(root);
            root->val = replacement->val;
            root->right = deleteNode(root->right, replacement->val, useSuccessor);
        } else {
            auto replacement = findPredecessor(root);
            root->val = replacement->val;
            root->left = deleteNode(root->left, replacement->val, useSuccessor);
        }
    }
    return root;
}

Node* findSuccessor(Node* node) { Node* current = node->right; while (current->left) { current = current->left; } return current; }

Node* findPredecessor(Node* node) { Node* current = node->left; while (current->right) { current = current->right; } return current; }

Node* deleteNode(Node* root, int target, int useSuccessor) { if (root == NULL) { return root; } if (target < root->val) { root->left = deleteNode(root->left, target, useSuccessor); } else if (target > root->val) { root->right = deleteNode(root->right, target, useSuccessor); } else if (!root->left && !root->right) { free(root); return NULL; } else if (!root->left) { Node* tmp = root->right; free(root); return tmp; } else if (!root->right) { Node* tmp = root->left; free(root); return tmp; } else { if (useSuccessor) { Node* replacement = findSuccessor(root); root->val = replacement->val; root->right = deleteNode(root->right, replacement->val, useSuccessor); } else { Node* replacement = findPredecessor(root); root->val = replacement->val; root->left = deleteNode(root->left, replacement->val, useSuccessor); } } return root; }

</TabItem>
<TabItem label="Rust">
```rs
fn find_successor(node: &Node) -> i32 {
    let mut cur = node;
    while let Some(ref left) = cur.left {
        cur = left;
    }
    cur.val
}

fn find_predecessor(node: &Node) -> i32 {
    let mut cur = node;
    while let Some(ref right) = cur.right {
        cur = right;
    }
    cur.val
}

pub fn delete_node(root: Option<Box<Node>>, target: i32, use_successor: bool) -> Option<Box<Node>> {
    match root {
        None => None,
        Some(mut node) => {
            if target < node.val {
                node.left = delete_node(node.left.take(), target, use_successor);
                Some(node)
            } else if target > node.val {
                node.right = delete_node(node.right.take(), target, use_successor);
                Some(node)
            } else {
                match (node.left.take(), node.right.take()) {
                    (None, None) => None,
                    (left, None) => left,
                    (None, right) => right,
                    (left, right) => {
                        let repl = if use_successor {
                            find_successor(&*right.as_ref().unwrap())
                        } else {
                            find_predecessor(&*left.as_ref().unwrap())
                        };
                        node.val = repl;
                        if use_successor {
                            node.right = delete_node(right, repl, true);
                            node.left = left;
                        } else {
                            node.left = delete_node(left, repl, false);
                            node.right = right;
                        }
                        Some(node)
                    }
                }
            }
        }
    }
}

Iterative

Note that the helper functions now also return the current node and the parent node as a tuple.

def find_predecessor(node): current = node.left parent = node while current.right is not None: parent = current current = current.right return current, parent

def delete(root, key, use_successor=True): if root is None: return root

parent = None
current = root

while current is not None and current.val != key:
    parent = current
    current = current.left if key < current.val else current.right

if current is None:
    return root

if current.left is None and current.right is None:
    if parent is None:
        return None  
    elif parent.left == current:
        parent.left = None
    else:
        parent.right = None

elif current.left is None:
    if parent is None:
        return current.right
    elif parent.left == current:
        parent.left = current.right
    else:
        parent.right = current.right

elif current.right is None:
    if parent is None:
        return current.left 
    elif parent.left == current:
        parent.left = current.left
    else:
        parent.right = current.left

else:
    if use_successor:
        replacement, replacement_parent = find_successor(current)
    else:
        replacement, replacement_parent = find_predecessor(current)

    current.val = replacement.val

    if use_successor:
        if replacement_parent == current:
            replacement_parent.right = replacement.right
        else:
            replacement_parent.left = replacement.right
    elif replacement_parent == current:
        replacement_parent.left = replacement.left
    else:
        replacement_parent.right = replacement.left

return root

</TabItem>
<TabItem label="Javascript">
```js
function findSuccessor(node) {
    let current = node.right;
    let parent = node;
    while (current.left !== null) {
        parent = current;
        current = current.left;
    }
    return [current, parent];
}

function findPredecessor(node) {
    let current = node.left;
    let parent = node;
    while (current.right !== null) {
        parent = current;
        current = current.right;
    }
    return [current, parent];
}

function deleteNode(root, key, useSuccessor = true) {
    if (root === null) {
      return root;
    }

    let parent  = null;
    let current = root;
    
    while (current !== null && current.val !== key) {
        parent  = current;
        current = key < current.val ? current.left : current.right;
    }
    if (current === null) {
        return root;
    }

    switch (true) {
      case (current.left === null && current.right === null):
        if (parent === null) {
          root = null;
        } else if (parent.left === current) {
          parent.left = null;
        } else {
          parent.right = null;
        }
        break;

      case (current.left === null):
        if (parent === null) {
          root = current.right;
        } else if (parent.left === current) {
          parent.left = current.right;
        } else {
          parent.right = current.right;
        }
        break;

      case (current.right === null):
        if (parent === null) {
          root = current.left;
        } else if (parent.left === current) {
          parent.left = current.left;
        } else {
          parent.right = current.left;
        }
        break;

      default: {
        const [replacement, replacementParent] = useSuccessor
          ? findSuccessor(current)
          : findPredecessor(current);

        current.val = replacement.val;

        if (useSuccessor) {
          if (replacementParent === current) {
            replacementParent.right = replacement.right;
          } else {
            replacementParent.left =  replacement.right;
          }
        } else {
          if (replacementParent === current) {
            replacementParent.left = replacement.left;
          } else {
            replacementParent.right = replacement.left;
          }
        }
      }
    }

    return root;
}

func findPredecessor(node *Node) (*Node, *Node) { current := node.Left parent := node for current.Right != nil { parent = current current = current.Right } return current, parent }

func deleteNode(root *Node, key int, useSuccessor bool) *Node { if root == nil { return nil }

var parent *Node
current := root
for current != nil && current.Val != key {
	parent = current
	if key < current.Val {
		current = current.Left
	} else {
		current = current.Right
	}
}

if current == nil {
	return root
}

switch {
case current.Left == nil && current.Right == nil:
	if parent == nil {
		return nil
	} else if parent.Left == current {
		parent.Left = nil
	} else {
		parent.Right = nil
	}

case current.Left == nil:
	if parent == nil {
		return current.Right
	} else if parent.Left == current {
		parent.Left = current.Right
	} else {
		parent.Right = current.Right
	}

case current.Right == nil:
	if parent == nil {
		return current.Left
	} else if parent.Left == current {
		parent.Left = current.Left
	} else {
		parent.Right = current.Left
	}

default:
	var repl, replParent *Node
	if useSuccessor {
		repl, replParent = findSuccessor(current)
	} else {
		repl, replParent = findPredecessor(current)
	}
	current.Val = repl.Val

	if useSuccessor {
		if replParent == current {
			replParent.Right = repl.Right
		} else {
			replParent.Left = repl.Right
		}
	} else {
		if replParent == current {
			replParent.Left = repl.Left
		} else {
			replParent.Right = repl.Left
		}
	}
}

return root

}

</TabItem>
<TabItem label="Java">
```java
class NodeParentPair {
    Node node;
    Node parent;
    
    NodeParentPair(Node node, Node parent) {
        this.node = node;
        this.parent = parent;
    }
}

public class BSTDeletion {
    
    public static NodeParentPair findSuccessor(Node node) {
        Node current = node.right;
        Node parent = node;
        while (current.left != null) {
            parent = current;
            current = current.left;
        }
        return new NodeParentPair(current, parent);
    }
    
    public static NodeParentPair findPredecessor(Node node) {
        Node current = node.left;
        Node parent = node;
        while (current.right != null) {
            parent = current;
            current = current.right;
        }
        return new NodeParentPair(current, parent);
    }
    
    public static Node deleteNode(Node root, int key, boolean useSuccessor) {
        if (root == null) {
            return root;
        }
        
        Node parent = null;
        Node current = root;
        
        while (current != null && current.val != key) {
            parent = current;
            current = key < current.val ? current.left : current.right;
        }
        
        if (current == null) {
            return root;
        }
        
        if (current.left == null && current.right == null) {
            if (parent == null) {
                return null;
            } else if (parent.left == current) {
                parent.left = null;
            } else {
                parent.right = null;
            }
        }
        else if (current.left == null) {
            if (parent == null) {
                return current.right;
            } else if (parent.left == current) {
                parent.left = current.right;
            } else {
                parent.right = current.right;
            }
        }
        else if (current.right == null) {
            if (parent == null) {
                return current.left;
            } else if (parent.left == current) {
                parent.left = current.left;
            } else {
                parent.right = current.left;
            }
        }
        else {
            NodeParentPair replacementPair;
            if (useSuccessor) {
                replacementPair = findSuccessor(current);
            } else {
                replacementPair = findPredecessor(current);
            }
            
            Node replacement = replacementPair.node;
            Node replacementParent = replacementPair.parent;
            
            current.val = replacement.val;
            
            if (useSuccessor) {
                if (replacementParent == current) {
                    replacementParent.right = replacement.right;
                } else {
                    replacementParent.left = replacement.right;
                }
            } else {
                if (replacementParent == current) {
                    replacementParent.left = replacement.left;
                } else {
                    replacementParent.right = replacement.left;
                }
            }
        }
        
        return root;
    }
}

public NodeParentPair(Node node, Node parent) 
{
    Node = node;
    Parent = parent;
}

}

public class BSTDeletion { public static NodeParentPair FindSuccessor(Node node) { Node current = node.right; Node parent = node; while (current.left != null) { parent = current; current = current.left; } return new NodeParentPair(current, parent); }

public static NodeParentPair FindPredecessor(Node node) 
{
    Node current = node.left;
    Node parent = node;
    while (current.right != null) 
    {
        parent = current;
        current = current.right;
    }
    return new NodeParentPair(current, parent);
}

public static Node DeleteNode(Node root, int key, bool useSuccessor = true) 
{
    if (root == null) 
    {
        return root;
    }
    
    Node parent = null;
    Node current = root;
    
    while (current != null && current.val != key) 
    {
        parent = current;
        current = key < current.val ? current.left : current.right;
    }
    
    if (current == null) 
    {
        return root;
    }
    
    if (current.left == null && current.right == null) 
    {
        if (parent == null) 
        {
            return null;
        } 
        else if (parent.left == current) 
        {
            parent.left = null;
        } 
        else 
        {
            parent.right = null;
        }
    }
    else if (current.left == null) 
    {
        if (parent == null) 
        {
            return current.right;
        } 
        else if (parent.left == current) 
        {
            parent.left = current.right;
        } 
        else 
        {
            parent.right = current.right;
        }
    }
    else if (current.right == null) 
    {
        if (parent == null) 
        {
            return current.left;
        } 
        else if (parent.left == current) 
        {
            parent.left = current.left;
        } 
        else 
        {
            parent.right = current.left;
        }
    }
    else 
    {
        NodeParentPair replacementPair;
        if (useSuccessor) 
        {
            replacementPair = FindSuccessor(current);
        } 
        else 
        {
            replacementPair = FindPredecessor(current);
        }
        
        Node replacement = replacementPair.Node;
        Node replacementParent = replacementPair.Parent;
        
        current.val = replacement.val;
        
        if (useSuccessor) 
        {
            if (replacementParent == current) 
            {
                replacementParent.right = replacement.right;
            } 
            else 
            {
                replacementParent.left = replacement.right;
            }
        } 
        else 
        {
            if (replacementParent == current) 
            {
                replacementParent.left = replacement.left;
            } 
            else 
            {
                replacementParent.right = replacement.left;
            }
        }
    }
    
    return root;
}

}

</TabItem>
<TabItem label="C++">
```cpp
std::pair<Node*, Node*> findSuccessor(Node* node) {
    Node* current = node->right;
    Node* parent = node;
    while (current->left != nullptr) {
        parent = current;
        current = current->left;
    }
    return std::make_pair(current, parent);
}

std::pair<Node*, Node*> findPredecessor(Node* node) {
    Node* current = node->left;
    Node* parent = node;
    while (current->right != nullptr) {
        parent = current;
        current = current->right;
    }
    return std::make_pair(current, parent);
}

Node* deleteNode(Node* root, int key, bool useSuccessor = true) {
    if (root == nullptr) {
        return root;
    }
    
    Node* parent = nullptr;
    Node* current = root;
    
    while (current != nullptr && current->val != key) {
        parent = current;
        current = key < current->val ? current->left : current->right;
    }
    
    if (current == nullptr) {
        return root;
    }
    
    if (current->left == nullptr && current->right == nullptr) {
        if (parent == nullptr) {
            delete current;
            return nullptr;
        } else if (parent->left == current) {
            parent->left = nullptr;
        } else {
            parent->right = nullptr;
        }
        delete current;
    }
    else if (current->left == nullptr) {
        Node* rightChild = current->right;
        if (parent == nullptr) {
            delete current;
            return rightChild;
        } else if (parent->left == current) {
            parent->left = rightChild;
        } else {
            parent->right = rightChild;
        }
        delete current;
    }
    else if (current->right == nullptr) {
        Node* leftChild = current->left;
        if (parent == nullptr) {
            delete current;
            return leftChild;
        } else if (parent->left == current) {
            parent->left = leftChild;
        } else {
            parent->right = leftChild;
        }
        delete current;
    }
    else {
        std::pair<Node*, Node*> replacementPair;
        if (useSuccessor) {
            replacementPair = findSuccessor(current);
        } else {
            replacementPair = findPredecessor(current);
        }
        
        Node* replacement = replacementPair.first;
        Node* replacementParent = replacementPair.second;
        
        current->val = replacement->val;
        
        if (useSuccessor) {
            if (replacementParent == current) {
                replacementParent->right = replacement->right;
            } else {
                replacementParent->left = replacement->right;
            }
        } else {
            if (replacementParent == current) {
                replacementParent->left = replacement->left;
            } else {
                replacementParent->right = replacement->left;
            }
        }
        delete replacement;
    }
    
    return root;
}

NodeParentPair findPredecessor(Node* node) { Node* current = node->left; Node* parent = node; while (current->right != NULL) { parent = current; current = current->right; } NodeParentPair pair = {current, parent}; return pair; }

Node* deleteNode(Node* root, int key, bool useSuccessor) { if (root == NULL) { return root; }

Node* parent = NULL;
Node* current = root;

while (current != NULL && current->val != key) {
    parent = current;
    current = key < current->val ? current->left : current->right;
}

if (current == NULL) {
    return root;
}

if (current->left == NULL && current->right == NULL) {
    if (parent == NULL) {
        free(current);
        return NULL;
    } else if (parent->left == current) {
        parent->left = NULL;
    } else {
        parent->right = NULL;
    }
    free(current);
}
else if (current->left == NULL) {
    Node* rightChild = current->right;
    if (parent == NULL) {
        free(current);
        return rightChild;
    } else if (parent->left == current) {
        parent->left = rightChild;
    } else {
        parent->right = rightChild;
    }
    free(current);
}
else if (current->right == NULL) {
    Node* leftChild = current->left;
    if (parent == NULL) {
        free(current);
        return leftChild;
    } else if (parent->left == current) {
        parent->left = leftChild;
    } else {
        parent->right = leftChild;
    }
    free(current);
}
else {
    NodeParentPair replacementPair;
    if (useSuccessor) {
        replacementPair = findSuccessor(current);
    } else {
        replacementPair = findPredecessor(current);
    }
    
    Node* replacement = replacementPair.node;
    Node* replacementParent = replacementPair.parent;
    
    current->val = replacement->val;
    
    if (useSuccessor) {
        if (replacementParent == current) {
            replacementParent->right = replacement->right;
        } else {
            replacementParent->left = replacement->right;
        }
    } else {
        if (replacementParent == current) {
            replacementParent->left = replacement->left;
        } else {
            replacementParent->right = replacement->left;
        }
    }
    free(replacement);
}

return root;

}

void freeTree(Node* root) { if (root != NULL) { freeTree(root->left); freeTree(root->right); free(root); } }

</TabItem>
<TabItem label="Rust">
```rs
fn remove_successor(node: &mut Node) -> i32 {
    if let Some(mut right) = node.right.take() {
        if right.left.is_none() {
            let val = right.val;
            node.right = right.right.take();
            val
        } else {
            let mut current = &mut right;
            while current.left.as_ref().unwrap().left.is_some() {
                current = current.left.as_mut().unwrap();
            }
            let mut successor = current.left.take().unwrap();
            let val = successor.val;
            current.left = successor.right.take();
            node.right = Some(right);
            val
        }
    } else {
        node.val
    }
}

fn remove_predecessor(node: &mut Node) -> i32 {
    if let Some(mut left) = node.left.take() {
        if left.right.is_none() {
            let val = left.val;
            node.left = left.left.take();
            val
        } else {
            let mut current = &mut left;
            while current.right.as_ref().unwrap().right.is_some() {
                current = current.right.as_mut().unwrap();
            }
            let mut predecessor = current.right.take().unwrap();
            let val = predecessor.val;
            current.right = predecessor.left.take();
            node.left = Some(left);
            val
        }
    } else {
        node.val
    }
}

pub fn delete_node(root: Option<Box<Node>>, key: i32, use_successor: bool) -> Option<Box<Node>> {
    let mut root = root?;
    
    if root.val == key {
        return match (&root.left, &root.right) {
            (None, None) => None,
            (Some(_), None) => root.left.take(),
            (None, Some(_)) => root.right.take(),
            (Some(_), Some(_)) => {
                if use_successor {
                    root.val = remove_successor(&mut root);
                } else {
                    root.val = remove_predecessor(&mut root);
                }
                Some(root)
            }
        };
    }
    
    let mut current = &mut root;
    loop {
        let go_left = key < current.val;
        let target = if go_left { &mut current.left } else { &mut current.right };
        
        match target {
            None => return Some(root),
            Some(node) if node.val == key => {
                match (&node.left, &node.right) {
                    (None, None) => {
                        *target = None;
                    }
                    (Some(_), None) => {
                        *target = node.left.take();
                    }
                    (None, Some(_)) => {
                        *target = node.right.take();
                    }
                    (Some(_), Some(_)) => {
                        if use_successor {
                            node.val = remove_successor(node);
                        } else {
                            node.val = remove_predecessor(node);
                        }
                    }
                }
                break;
            }
            Some(node) => {
                current = node;
            }
        }
    }
    
    Some(root)
}

Time Complexity

For any BST operation (search, insert, delete), the time complexity is O(h) where h is the tree's height.

| Tree Structure | Height (h) | Time Complexity | Example | |:---------------|:-----------|:----------------|:--------| | Balanced | O(log n) | O(log n) | Perfect binary tree | | Unbalanced | O(n) | O(n) | Linked list structure / skewed |

Balanced Trees (Best Case)

Height approximately log₂ n
Performance: O(log n) for all operations
Example: With 1,000 nodes, height ≈ 10 levels

Skewed Trees (Worst Case)

Height equals n (essentially a linked list)
Performance: O(n) for all operations
Example: Inserting sorted data: 1→2→3→4→5

Space Complexity

| Implementation | Space Complexity | Notes | |:---------------|:----------------|:------| | Recursive | O(h) | Call stack grows with height | | Iterative | O(1) | Constant extra space |

Why Balancing Matters

Without balancing:

Sorted input creates O(n) height
Performance degrades to linear search
Defeats the purpose of using a BST

With self-balancing (AVL, Red-Black):

Automatic rotations maintain O(log n) height
Guaranteed logarithmic performance
Slight overhead for rebalancing operations

Common Pitfalls

Inserting sorted data leads to an unbalanced, degenerate tree (poor performance).
BST property violations can occur with incorrect insert/delete logic.
Duplicate values: handle as per requirements (left/right, or disallow).
Memory leaks in C/C++ when forgetting to free deleted nodes.
Parent pointer management errors during deletion (especially with two children).
Edge case bugs: deleting root node, single-node trees, or non-existent keys.
Mixing recursive/iterative approaches inconsistently in the same codebase.
Assuming balanced performance without using self-balancing variants.

Summary

Best Practice: Use self-balancing BSTs (AVL, Red-Black) for guaranteed O(log n) performance.
Height Determines Performance: All BST operations are O(h); balanced trees ensure optimal performance.
Iterative vs. Recursive:
- Recursive approaches are simpler and easier to understand, suitable when height (h) is guaranteed to be O(log n).
- Iterative approaches can optimize space complexity O(1), beneficial when height could be large (potentially O(n)) or in memory-constrained environments.

What's Next

In Post 4: Self-Balancing Trees - AVL and Red-Black, we'll build on our BST foundations to see:

Rotations (left & right) step by step
Invariants that distinguish AVL vs. Red-Black trees
When to pick which structure for your use case

Binary Tree Traversal: Navigating Binary Trees Effectively

Mon, 14 Jul 2025 19:45:00 GMT

import { Aside, Collapse, MdxRepl, Tabs, TabItem } from "astro-pure/user" import TreeExample from "tree-traversal.svg"; import NodeCycler from '@/components/NodeCycler.astro';

In our previous post, Binary Trees 101, we introduced the basics of binary trees, covering their structures, properties, and practical representations. Now that you've got a solid grasp of binary tree fundamentals, let's explore one of the most essential concepts when working with these data structures: tree traversals.

Traversals allow us to systematically visit each node in a binary tree, serving as the foundation for many critical operations like searching, inserting, and deleting data.

Key Topics

Recursive vs Iterative Approaches: The two main strategies for traversing trees.
Traversal Techniques: Pre-order, in-order, post-order, and level-order traversals, each with distinct characteristics and use-cases.
Real-world Applications: Understanding when and why to use each traversal type, such as in-order for Binary Search Trees (BSTs).

DFS vs BFS Traversals

There are two fundamental strategies for traversing trees:

Depth-First Search (DFS):
Explores as deep as possible down each branch before backtracking.
Includes: Pre-order, In-order, and Post-order traversals.
Breadth-First Search (BFS):
Explores all nodes at each level before moving to the next.
Includes: Level-order traversal.

Types of Tree Traversals

Before diving into code, let's cover the core strategies for traversing a binary tree:

Recursive: Leverages the language's call stack, naturally mirroring the tree's structure. Most traversal algorithms are elegant and concise in recursive form.
Iterative: Uses explicit data structures like stacks (for DFS) or queues (for BFS) to manage traversal state, which can avoid recursion limits and sometimes improve performance.

Traversal Orders & Use-Cases

Traversal Examples

Pre-order Traversal (Root, Left, Right)

Pre-order traversal visits the root node first, then explores the left subtree, followed by the right subtree. It's called pre-order because each node is processed before its left and right subtrees are visited.

Recursive

The recursive version uses the programming language's call stack to keep track of where it is in the tree.

Visit the Node: At each function call, process the current node (e.g. print its value or add it to a result list).
Traverse Left: Recursively call the function on the node's left child. This continues down the leftmost path first.
Traverse Right: After finishing the left subtree, recursively call the function on the node's right child.
Base Case: If the function reaches a node that is None (or null), it returns immediately—meaning there's nothing left to visit at that branch.

Iterative

Instead of using recursion, the iterative version explicitly manages the nodes to visit using a stack.

Initialization: Start by pushing the root node onto the stack.
Processing: While the stack isn't empty, pop the top node, visit it (add its value to the result list), and then push its right and left children (if any) onto the stack.
Order: By pushing the right child before the left child, we ensure the left child is processed first (since stacks are LIFO—last in, first out).
Repeat: Continue this process until there are no more nodes left in the stack.

public class TreeTraversal {
    public List<Integer> preorder(Node root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) return result;
        Deque<Node> stack = new ArrayDeque<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            result.add(node.val);
            if (node.right != null) stack.push(node.right);
            if (node.left  != null) stack.push(node.left);
        }
        return result;
    }
}
```

In-order Traversal (Left, Root, Right)

In-order traversal explores the left subtree first, then processes the root node, and finally visits the right subtree. This approach is especially valuable for Binary Search Trees, as it retrieves values in ascending order.

It's called in-order because each node is visited between traversing its left and right subtrees, after finishing the left, but before starting the right.

Recursive

Traverse Left: Recursively call the function on the node's left child, moving as far left as possible in the tree.
Visit the Node: Once there are no more left children, process the current node (e.g. print its value or add it to a result list).
Traverse Right: After visiting the node, recursively call the function on the right child to process the right subtree.
Base Case: If the function reaches a None (or null) node, it returns immediately—meaning there's nothing left to visit in that branch.

Iterative

Initialization: Start with an empty stack and set the current node to the root.
Go Left: Move as far left as possible, pushing each node onto the stack as you go.
Visit the Node: Once you reach a node with no left child, pop a node from the stack and process it (print/add its value).
Go Right: After visiting the node, move to its right child and repeat the process.
Repeat: Continue this loop (go left, visit, go right) until both the stack is empty and there are no more nodes to process.

Post-order Traversal (Left, Right, Root)

Post-order traversal explores the left subtree first, then the right subtree, and processes the current node last. This approach is particularly useful for tasks like deleting a tree, since you want to delete children before the parent, or evaluating postfix expressions.

It's called post-order because each node is processed after both its subtrees have been visited.

Recursive

Traverse Left: Recursively call the function on the node's left child.
Traverse Right: Recursively call the function on the node's right child.
Visit the Node: Process the current node (e.g. print its value or add it to a result list).
Base Case: If the function reaches a node that is None (or null), it returns immediately.

Iterative

Instead of recursion, the iterative version explicitly manages nodes to visit using a stack. Post-order is trickier to implement iteratively than pre-order or in-order.

Initialization: Start by pushing the root node onto the stack.
Processing: Pop nodes from the stack, and push them onto a visited stack, or prepend their value to the result list. Push left child first, then right child, so right is processed before left.
Repeat: Continue until the stack is empty.
Result: The visited stack or reversed result list gives the post-order traversal.

This approach is ideal for collecting values in post-order, but not suitable for tree modification, like deleting nodes or freeing memory, where you must visit a node only after both children have been processed.

While the reverse pre-order trick is great for collecting values, sometimes you need to process a node only after both children are finished (e.g. to free nodes or modify the tree). Here are two classic techniques for this:

One Stack With Visited State: Use a single stack but track the last visited node. Only process a node after both its left and right children are done. This approach closely matches recursion, but is more complex to implement.
Two Stack Method: Use one stack for traversal and a second stack, or list, to collect the nodes in post-order. This also results in O(n) time and space.

These approaches are more advanced, and not usually needed for simple traversals, but they're useful to know about.

Level-order Traversal (BFS)

Level-order traversal visits all nodes at each depth of the tree, starting from the root and working level by level from left to right. This method is also known as breadth-first traversal, as it explores all nodes on one level before moving to the next.

Level-order traversal is essential for:
Printing a tree level by level, like a hierarchy or org chart.
Finding the shortest path in an unweighted tree
Serialising and deserialising trees for storage or transmission
Solving problems that require processing nodes in order of their depth

For the tree above, level-order traversal visits nodes by row, starting from the root: R, A, B, C, D, E, F, G. This order ensures all nodes at depth n are visited before any node at depth n+1.

Level-order traversal is most naturally implemented using a queue (FIFO), rather than a stack, or recursively.

Iterative

Initialization: Start by enqueueing the root node.
Processing: While the queue isn't empty:

Dequeue the front node and process it (e.g. print/add its value).
Enqueue its left child, if any, then its right child, if any.

Repeat: Continue until the queue is empty.

def levelorder(root: Node):
    if not root:
        return []
    queue = deque([root])
    result = []
    while queue:
        node = queue.popleft()
        result.append(node.value)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result
```

Recursive

Level-order traversal is rarely implemented recursively because recursion alone doesn't naturally handle breadth-first order. However, it can be done using a helper function that visits nodes by their level:

Recap

Hopefully, you now know the four essential ways to traverse a binary tree: pre-order, in-order, post-order, and level-order. Each with their own strengths, typical applications, and recursive or iterative solutions. These patterns form the backbone of almost every binary tree algorithm, from basic searches to complex transformations. The examples will be updated over time other languages.

There are even more advanced approaches, like Morris Traversal, that allow in-order traversal with O(1) extra space. We'll cover these in a future post. </ Aside>

Up Next: Binary Search Trees (BSTs)

In our next post, we'll explore one of the most powerful uses of binary trees: the Binary Search Tree (BST).

We'll cover:

How BSTs organize data for fast search, insert, and delete operations
Step-by-step BST algorithms (with code and visuals)
How to analyse best-case and worst-case performance
Common pitfalls, balancing needs, and when to use BSTs in practice

Stay tuned for Binary Search Trees: Fast Search, Insert, & Delete coming next!

Binary Trees 101

Sat, 12 Jul 2025 21:00:00 GMT

import { Aside, MdxRepl, Tabs, TabItem } from "astro-pure/user" import BinaryTree from "binary-tree.svg"; import BalancedTree from "balanced.svg"; import FullTree from "fulltree.svg"; import PerfectTree from "perfect.svg"; import UnBalancedTree from "unbalanced.svg"; import SkewedTree from "skewed.svg"; import DegenTree from "degenerate.svg"; import FileSys from "filesys.svg";

I was watching a friend stream the other day, and they were prepping for an upcoming interview. The topic being studied? Binary trees.

This got me thinking about the role binary trees play in today"s programming landscape. They"re no longer just academic exercises; they"ve become something of a rite of passage, popularized by coding challenge platforms like LeetCode and Codewars.

In reality, most developers won"t build a red-black tree every day on the job. Still, understanding their structures, properties, and traversal methods pays dividends across parsing, priority queues, file-system hierarchies, and beyond.

What is a Binary Tree?

A binary tree is a non-linear and hierarchical data structure in which each node has at most two children, commonly called left and right. Unlike linear data structures (arrays/lists, linked lists, stacks, queues), binary trees organise data in a tree-like structure that allows for efficient searching, insertion, and deletion operations.

Node: Holds a value (data)
Root: The topmost node (entry point)
Edge: The link between any two nodes
Child: A node reachable directly from another node
Leaf: A node with no children
Subtree: Any node plus all its descendants
Height of a Node: Number of edges from the node to the deepest leaf
Depth of a Node: Number of edges from the root to the node.
Height of a Tree: Height of the root node or the depth of the deepest node.

Representation

Before we take a look at the many types and algorithms for binary trees, it"s important to understand how they are represented in code. The representation you choose can have a major impact on memory usage, performance, and which algorithms are practical.

There are two common ways to represent a binary tree in practice:

Pointer (Node) Representation:
Each node is an object or struct, and has explicit references (pointers) to its left and right child nodes.
Array (Implicit) Representation:
The tree is mapped onto an array or list, with parent/child relationships determined by index calculations. This approach is especially efficient for "complete" binary trees, such as heaps.

Let"s see how these look.

Pointer

Each node contains a value, and pointers or references to its left and right children.
This is the most general and flexible way to represent binary trees of any shape. It is also easy to insert, remove, or restructure the tree.

The trade off is that extra memory is used for pointers and may be slower for large trees.

public Node(int val=0, Node left=null, Node right=null) {
    this.val = val;
    this.left = left;
    this.right = right;

</TabItem>
<TabItem label="C++">
```cpp
//Struct
struct Node {
    int data;
    Node* left, * right;

    Node(int key) {
        data = key;
        left = nullptr;
        right = nullptr;
    }
};

//Class
class Node {
public:
    int data;
    Node* left, * right;

    Node(int key) {
        data = key;
        left = nullptr;
        right = nullptr;
    }
};

// Function to create a new tree node struct Node* newNode(int item) { struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); temp->data = item;
temp->left = temp->right = NULL; return temp; }

</TabItem>
<TabItem label="Rust">
```rs
struct Node {
    val: i32,
    left: Option<Box<Node>>,
    right: Option<Box<Node>>,
}

impl Node {
    fn new(val: i32) -> Self {
        Node {
            val,
            left: None,
            right: None,
        }
    }
}

Array

A binary tree can also be stored as an array, where for any node at index i:

The left child is at 2i + 1
The right child is at 2i + 2

This is especially efficient for complete binary trees (e.g. heaps). Array representation does not require pointers, so memory is saved, and are cache friendly.

They are not so good for sparse, skewed, or highly unbalanced trees. They are also hard to restructure dynamically.

def left_child_index(index: int) -> int: return 2 * index + 1

def right_child_index(index: int) -> int: return 2 * index + 2

def get_data(index: int) -> str | None: if 0 <= index < len(binary_tree_array): return binary_tree_array[index] return None

right_child = right_child_index(0) left_child_of_right_child = left_child_index(right_child) data = get_data(left_child_of_right_child)

print("root.right.left.data:", data)

F

</TabItem>
<TabItem label="Javascript">
```js
const binary_tree_array = ["A", "B", "C", "D", null, "F"];

function leftChildIndex(index) {
  return 2 * index + 1;
}

function rightChildIndex(index) {
  return 2 * index + 2;
}

function getData(index) {
  if (index >= 0 && index < binary_tree_array.length) {
    return binary_tree_array[index];
  }
  return null;
}

const right_child = rightChildIndex(0);
const left_child_of_right_child = leftChildIndex(right_child);
const data = getData(left_child_of_right_child);

console.log("root.right.left.data:", data);
>>> F

import ( "fmt" )

func leftChildIndex(index int) int { return 2*index + 1 }

func rightChildIndex(index int) int { return 2*index + 2 }

func getData(tree []string, index int) string { if index >= 0 && index < len(tree) { return tree[index] } return "nil" }

func main() { binaryTreeArray := []string{"A", "B", "C", "D", "", "F"}

rightChild := rightChildIndex(0)
leftChildOfRightChild := leftChildIndex(rightChild)
data := getData(binaryTreeArray, leftChildOfRightChild)

fmt.Println("root.right.left.data:", data)

}

F

</TabItem>
<TabItem label="Java">
```java
public class BinaryTreeArrayExample {
    public static void main(String[] args) {
        String[] binaryTreeArray = {"A", "B", "C", "D", null, "F"};

        int rightChild = rightChildIndex(0);
        int leftChildOfRightChild = leftChildIndex(rightChild);
        String data = getData(binaryTreeArray, leftChildOfRightChild);

        System.out.println("root.right.left.data: " + data);
    }

    static int leftChildIndex(int index) {
        return 2 * index + 1;
    }

    static int rightChildIndex(int index) {
        return 2 * index + 2;
    }

    static String getData(String[] tree, int index) {
        if (index >= 0 && index < tree.length) {
            return tree[index];
        }
        return null;
    }
}

>>> F

Which representation to use?

Use a pointer for general purpose trees or when you know the tree can be irregular.
Use an array when you know the tree will always be complete or balanced.

Types of Binary Tree

By Shape

The shape of a binary tree has a major impact on performance and on which algorithms apply:

| Shape | Definition | Example Use | |--------------|----------------------------------------------------------------------------------------------|-------------------------------| | Full | Every node has 0 or 2 children (no nodes with just one child). | Some balanced tree invariants | | Complete | All levels are completely filled except possibly the last, which is filled left to right. | Heaps (priority queues) | | Perfect | All internal nodes have 2 children; all leaves are at the same depth/level. | Theoretical analyses | | Skewed | Every node has only one child; all left (left-skewed) or all right (right-skewed). | Worst-case BST degeneracy | | Degenerate | Every node has only one child; can be left or right. | Linked lists; unbalanced BSTs | | Balanced | Heights of left/right subtrees at every node differ by at most 1 (or a constant). | AVL, Red-Black, fast search |

Note: Trees can satisfy multiple properties (e.g. a perfect tree is also full, complete, and balanced).

By Property or Use

Binary trees are also classified by the properties of their nodes or how they are used in algorithms:

| Property/Type | Definition | Example Use | |--------------------|---------------------------------------------------------------------------------------|----------------------------| | Binary Search Tree (BST) | For each node, all values in the left subtree are less than the node, and all values in the right subtree are greater. Fast search, insert, delete. | Dictionary/map, database | | AVL Tree | Self-balancing BST (height difference at most 1 at each node). | Faster, guaranteed search | | Red-Black Tree | Self-balancing BST with red/black color rules. | Sets/maps in C++, Java | | Threaded Tree | Unused pointers point to in-order predecessor/successor for fast traversal. | Fast in-order traversal | | Heap | Complete tree with heap property (min or max at the root). | Priority queues, heapsort | | Expression Tree| Internal nodes are operators, leaves are operands. | Arithmetic evaluation | | Huffman Tree | Binary tree for optimal prefix code (compression). | Compression algorithms |

Basic Properties

When working with binary trees, there are two fundamental properties you'll regularly compute:

Size

The size of a binary tree is simply the total number of nodes it contains. A straightforward way to compute this is using recursion, counting the current node plus all nodes in its left and right subtrees:

def size(node):
    if not node:
        return 0
    return 1 + size(node.left) + size(node.right)

Height

The height of a binary tree is defined as the length of the longest path from the root down to a leaf. The height can be measured either by counting nodes or edges. Most commonly, nodes are counted. Here's a simple recursive implementation:

def height(node):
    if not node:
        return 0
    return 1 + max(height(node.left), height(node.right))

These basic properties serve as the foundation for more advanced tree operations and analyses you'll encounter.

Other Useful Properties

Depth (of a node): Number of edges from the root node to a given node (root has depth 0).
Level: Nodes at the same depth belong to the same level (root at level 0).
Width: Maximum number of nodes at any single level of the tree.
Diameter: Length of the longest path between any two nodes (doesn't necessarily pass through the root).

Root: A (level 0, depth 0)
Children: B, C (level 1)
Leaves: D, E, F (level 2)
Width: 3 nodes at the lowest level (D, E, F)
Diameter: Longest path is D → B → A → C → F (4 edges)

Practical Analogy: File-System Structure

One of the best practical analogies is your computer's file-system hierarchy.

Directories are nodes that can contain both files and other folders.
Files are leaves; they cannot contain anything else.

While actual directories can contain many children, we can still model this structure using a binary tree. The classic way to do this is called the left-child, right-sibling representation.

Left-Child, Right-Sibling Representation

When a directory contains more than two entries (files or subdirectories), we use a trick:

The left child points to the first item (file or directory) inside the directory.

The right child points to the next sibling at the same directory level.

So, you'd traverse left from the parent for the first child, then follow right children to reach the rest.

What's Next?

Now that you've got a solid grasp on binary tree shapes, properties, and representations, you're ready for the next step: tree traversals.

In the upcoming post, we'll explore:

Recursive vs iterative approaches
Pre-order, in-order, post-order, and level-order traversals
When, and why, each traversal shines

If you're comfortable with nodes and tree structures, you'll breeze through traversal patterns and see how these foundational concepts play out in real algorithms.

Stay tuned for Part 2: Tree Traversals!

Generics in Python: Simplifying Complexity

Sun, 28 Jul 2024 19:57:38 GMT

While hanging out in a Discord server a few days ago, someone brought up the topic of generics in Python. This sparked curiosity among several members, leading to questions about what generics are and how or when to use them. Generics aren't unique to Python, many programming languages use them as fundamental tools for creating robust and efficient software.

This conversation got me thinking it would be a great topic to explore together on this blog. So, let's dive into the basics of using generics in Python, discuss some variants, and discover how they can streamline our code and enhance its reliability.

What are generics?

Generics are designed to enhance the flexibility and safety of your code. Here's what they aim to do:

Enable Flexibility: They allow functions, methods, and classes to work with different data types while preserving information about the relationships between these data types, such as the consistency between input arguments and return values.
Improve Type Safety: Generics help specify how different types can interact more explicitly, reducing errors by clarifying the data types used in operations.

We achieve these benefits by using generic types—placeholders for data types—instead of specific or parent types when defining components. This allows your code to be both flexible and safe, accommodating various data types while ensuring operations are performed correctly.

If that sounds a bit abstract, don't worry! The best way to understand generics is to see them in action. Let’s dive into some simple examples to see how you can use generics in your Python projects to make your code more robust and flexible.

Using generics in Python

I'll begin by using the traditional approach familiar to most Python developers. This involves utilising TypeVar from the typing module. As we progress through the post, I'll also cover the Type Parameter Syntax introduced by PEP-695 in Python 3.12. This update brings several enhancements that simplify the declaration and usage of generics, and I’ll highlight some of its key nuances. It is also important to note that Python will not do anything special with the generics, it is dependent on the person running a type checker e.g. Pyright / Pylance, MyPy or Pyre.

This function accepts a list containing elements of any type and returns the first element. It uses the `` type to indicate that it can handle elements of any type without restriction.

from typing import Any

def get_first_item(items: list[Any]) -> Any:
    return items[0]

a: list[int] = [1, 2, 3]
b: list[str] = ["hello", "world"]
c: list[list[int]] = [[1, 2], [3, 4, 5]]

print(get_first_item(a))
print(get_first_item(b))
print(get_first_item(c))

So why choose a generic over using Any? The key advantage of using a generic lies in its ability to ensure consistency and type safety. With a generic, you can guarantee that the type returned by the function matches the type of the elements in the provided list. This consistency is not assured with Any.

from typing import TypeVar

T = TypeVar("T")

def get_first_item(items: list[T]) -> T:
    return items[0]

a: list[int] = [1, 2, 3]
b: list[str] = ["hello", "world"]
c: list[list[int]] = [[1, 2], [3, 4, 5]]

print(get_first_item(a))
print(get_first_item(b))
print(get_first_item(c))

Since the specific type of elements list contains is not of concern, rather only that the function returns the same type as provided in the list, we define a generic type named T with T = TypeVar("T"). This approach replaces the use of Any, which lacks this level of type specificity.

By using T, we introduce type safety to the get_first_item() function, safeguarding against issues like returning a transformed type or an incorrect literal. This setup ensures that our function's behaviour remains predictable and consistent, protecting against unintended coding errors.

def get_first_item(items: list[T]) -> T:
    return str(items[0]) # Expression of type "str" is incompatible with return type "T@get_first_item"

Let's look at one more simple example before we move on.

The below will warn that get_first_key() is expecting to return a key and not a value from the dictionary. But, as mentioned near the start of this post, this will not prevent the code from running and it will still print the first value, which is 1.

from typing import TypeVar

K = TypeVar("K")
V = TypeVar("V")

def get_first_key(container: dict[K, V]) -> K:
    return list(container.values())[0] # Expression of type "V@get_first" is incompatible with return type "K@get_first"

test: dict[str, int] = {"k": 1}
print(get_first_key(test))

Limiting generics to specific types

In the previous examples, we utilised generic types that could represent any possible type. But what if we want to narrow down and specifically limit the types that a generic can represent?

from typing import TypeVar

T = TypeVar("T", str, int)

def combine_elements(items: list[T]) -> str:
    return "".join(str(item) for item in items)

print(combine_elements(["hello", "world"]))  # Output: helloworld
print(combine_elements([1, 2, 3]))  # Output: 123

print(combine_elements([1.0, 2.0, 3.0])) # Argument of type "list[float]" cannot be assigned to parameter "items" of type "List[T@combine_elements]" in function "combine_elements"

Here we constrain T to only allow str and int types. When we try passing a list of floats we see the type checker warn that combine_elements() is not expecting this type.

We can also set an upper bound constraint, limiting the generic type to that specific type and any of its subclasses.

from typing import TypeVar

T = TypeVar("T", bound=int)

class X(int):
    pass

class Y(int):
    pass

def combine_coords(hour: T, minute: T) -> tuple[T,T]:
    return hour, minute

combine_coords(X(14), Y(50))
combine_coords(X(20), 50)

combine_coords("10", "50") # Argument of type "Literal['10']" cannot be assigned to parameter "hour" of type "T@combine_coords" in function "combine_coords" - Type "Literal['10']" is incompatible with type "int"

Generics with classes

By using generics in classes, developers can design components that are not tied to specific data types, thus increasing the utility and scalability of their code. A prime example is the implementation of data structures, such as lists, queues, and trees, which can hold any type of data but enforce type consistency within an instance. This approach eliminates common bugs that arise from type mismatches and enhances code safety.

from typing import Generic, TypeVar

T = TypeVar("T")

class Box(Generic[T]):
    def __init__(self) -> None:
        self._contents: list[T] = []

    def add(self, item: T) -> None:
        self._contents.append(item)

    def get_contents(self) -> list[T]:
        return self._contents

toy_box = Box[str]()
toy_box.add("Teddy Bear")
toy_box.add("Toy Car")

bolt_box = Box[int]() 
bolt_box.add(10) 
bolt_box.add(20)

bolt_box.add("Toy Hammer")

print(toy_box.get_contents())

We have created a Box class—a versatile container that can hold various specialised items. In our scenario, we have two types of boxes: a toy box and a bolt box. The toy box is designated for toys, represented as strings, like "Teddy Bear" or "Toy Car", and must be put away before bedtime. The bolt box is used for storing different sizes of bolts, represented as integers.

However, we've made a mistake by trying to add a "Toy Hammer" to our bolt box. Our type checker, as usual, will alert us to this mistake.

Argument of type "Literal['Toy Hammer']" cannot be assigned to parameter "item" of type "int" in function "add" "Literal['Toy Hammer']" is incompatible with "int"

But remember it will not prevent us from adding "Toy Hammer" to the list in Box.

Variants of generics

There are three variants of generics, which simply refer to different behaviours or specifications that can influence how type checking behaves.

Invariance

By default, all type variables in Python are invariant. Invariance means that if you have a generic type G[T], it cannot accept G[U], even if U is a subclass or superclass of T. Most mutable containers are invariant. e.g. list and dict.

For example, list[Animal] can not be used where list[Cat] is expected, where Animal is a superclass of Cat.

Covariance

A type variable is covariant if it allows a generic class to be substituted with a subclass. This is typically used for return types, where a method of a generic class promises to return a type T, and it’s safe to use a type U such that U is a subclass of T. You declare this in the TypeVar.

It's also important to note that when a generic class is covariant, it is recommended to be immutable / read-only. Some examples of this are typing.Sequence, typing.FrozenSet and typing.Union. Remember this for later in the post.

from typing import Generic, TypeVar

T_co = TypeVar("T_co", covariant=True, bound="Animal")

class Animal: ...

class Cat(Animal): ...

class Dog(Animal): ...

class Snake: ...

class AnimalShelter(Generic[T_co]):
    def __init__(self, animal: T_co) -> None:
        self.animal = animal
        
def adopt_animal(shelter: AnimalShelter[Animal]) -> Animal:
    return shelter.animal

cat = Cat()
dog = Dog()
snake = Snake()

cat_shelter = AnimalShelter(cat)
dog_shelter = AnimalShelter(dog)
reptile_shelter = AnimalShelter(snake)

adopt_cat = adopt_animal(cat_shelter)
adopt_dog = adopt_animal(dog_shelter)
adopt_snake = adopt_animal(reptile_shelter)

We define a TypeVar T_co that is marked as a covariant by setting covariant=True and bounding it to the Animal class. This means T_co can accept any subclass of Animal.
Using T_co, we create an AnimalShelter generic class that is initialised with an instance of Animal or its subclasses.
We define a function adopt_animal() that takes an AnimalShelter housing any Animal and returns the animal.
We create shelters for different animals, cats, dogs, and hypothetically, snakes. Since snakes are not a subclass of Animal they will trigger a type error:

Argument of type "Snake" cannot be assigned to parameter "animal" of type "T_co@AnimalShelter" in function "__init__" Type "Snake" is incompatible with type "Animal"

Contravariance

Allows substitution of a type with its supertype. For example, if a function expects a type of Cat, then it will also accept its supertype, Animal.

We define a type variable T_contra that is contravariant and bounded by the class Animal. This setup implies that wherever a specific type like Cat is expected, any of its supertypes (up to Animal) can be used instead.

from typing import Generic, TypeVar

T_contra = TypeVar("T_contra", contravariant=True, bound="Animal")

class Animal:
    def speak(self) -> str:
        return "Some noise"

class Cat(Animal):
    def speak(self) -> str:
        return "Meow"

class Handler(Generic[T_contra]):
    def handle(self, t: T_contra) -> None:
        print(t.speak())

def handle_animal(a: Handler[Cat]) -> None:
    a.handle(Cat())

handler: Handler[Animal] = Handler()
handle_animal(handler) 

cat_handler: Handler[Cat] = Handler()
dog_handler: Handler[Dog] = Handler()
handle_animal(cat_handler) 
handle_animal(dog_handler) # Type parameter "T_contra@Handler" is contravariant, but "Dog" is not a supertype of "Cat"

Generics with protocols

In practical applications, it's often beneficial to use a Protocol to define an interface. This approach ensures that any subclass implementing the interface will include the necessary methods, as enforced by type checking warnings.

from typing import Generic, TypeVar, Protocol

T_co = TypeVar("T_co", covariant=True, bound="Animal")
T_contra = TypeVar("T_contra", contravariant=True, bound="Animal")

class Animal(Protocol):
    def speak(self) -> str: ...

class Cat:
    def speak(self) -> str:
        return "Meow"

class Dog:
    def speak(self) -> str:
        return "Woof"

class Fish:
    def swim(self) -> None: ...
        
class Handler(Generic[T_contra]):
    def handle(self, t: T_contra) -> None:
        print(t.speak())

class AnimalShelter(Generic[T_co]):
    def __init__(self, animal: T_co) -> None:
        self.animal = animal

def adopt_animal(shelter: AnimalShelter[Animal]) -> Animal:
    return shelter.animal


def handle_animal(a: Handler[Cat]) -> None:
    a.handle(Cat())

handler: Handler[Animal] = Handler()
handle_animal(handler) 

cat_handler: Handler[Cat] = Handler()
fish_handler: Handler[Fish] = Handler() # "Fish" is incompatible with protocol "Animal"
handle_animal(cat_handler) 
handle_animal(fish_handler) # Type parameter "T_contra@Handler" is contravariant, but "Fish" is not a supertype of "Cat"

cat = Cat()
dog = Dog()
fish = Fish()
cat_shelter = AnimalShelter(cat)
dog_shelter = AnimalShelter(dog)
fish_shelter = AnimalShelter(fish) # Type "Fish" is incompatible with type "Animal"

In the example above, the Fish class does not implement the speak() method, therefore it does not meet the requirements of the Animal protocol. Because of that, you can't use Fish in situations where you need something that fits the Animal protocol, whether it's covariant or contravariant.

Python 3.12 Generics (PEP 695)

With PEP 695, we can streamline how generics are defined. Let's take our very first example.

from typing import TypeVar

T = TypeVar("T")

def get_first_item(items: list[T]) -> T:
    return items[0]
This would simply become

def get_first_item[T](items: list[T]) -> T:
    return items[0]

Note how we did not need to import and define the TypeVar for each generic. How about with a Protocol?

from typing import Protocol, TypeVar


C1 = TypeVar("C1")
C2 = TypeVar("C2") 

class CurrencyExchangeMapper(Protocol[C1, C2]):
    def to(self, amount: C1) -> C2: ...
    def from_(self, amount: C2) -> C1: ...

class USDGBPExchangeMapper(CurrencyExchangeMapper[float, float]):
    def __init__(self, exchange_rate: float, reverse_rate: float) -> None:
        self.exchange_rate = exchange_rate
        self.reverse_rate = reverse_rate

    def to(self, amount: float) -> float:
        return amount * self.exchange_rate

    def from_(self, amount: float) -> float:
        return amount * self.reverse_rate

exchange_mapper = USDGBPExchangeMapper(exchange_rate=0.777255, reverse_rate=1.28658)
print(f"100 USD is {exchange_mapper.to(100):.2f} GBP") 
print(f"100 GBP is {exchange_mapper.from_(100):.2f} USD")

The only part that changes is the CurrencyExchangeMapper class.

class CurrencyExchangeMapper[C1, C2](Protocol):
    def to(self, amount: C1) -> C2: ...
    def from_(self, amount: C2) -> C1: ...

Setting bounds and limiting types in PEP 695 are similar, but there is an important difference. With the enhancements introduced in PEP 695, type variance does not always need to be explicitly defined because it can often be inferred from the context.

from typing import Sequence

class DataBundle[T, B: Sequence[bytes], S: (int, str)]:
    def __init__(self, general: T, binary_data: B, identifier: S) -> None:
        self.general = general
        self.binary_data = binary_data
        self.identifier = identifier
        
# Pre 3.12

from typing import TypeVar, Generic, Sequence

T = TypeVar("T", contravariant=True)
B = TypeVar("B", bound=Sequence[bytes], covariant=True)
S = TypeVar("S", int, str)

class OldDataBundle(Generic[T, B, S]):
    def __init__(self, general: T, binary_data: B, identifier: S) -> None:
        self.general = general
        self.binary_data = binary_data
        self.identifier = identifier

Recall when I said to remember that covariants are recommended to be immutable / read-only? Well here is an example showing how PEP 695 is enforcing this with class generics. I personally find this stricter approach to be more correct, but it is a differing behaviour to class Thing(Generic[T]).

Note how this does not warn of any errors.

from typing import Generic, TypeVar

T_co = TypeVar("T_co", bound="Animal", covariant=True)

class Animal:
    pass

class Cat(Animal):
    pass

class AnimalShelter(Generic[T_co]):
    def __init__(self, animal: T_co) -> None:
        self.animal = animal

def adopt_animal(box: AnimalShelter[Animal]) -> Animal:
    return box.animal
    
cat = Cat()
rescue_cat = AnimalShelter(cat) 
my_cat = adopt_animal(rescue_cat)

Now if we convert this to the PEP 695 way

class Animal:
    pass

class Cat(Animal):
    pass

class AnimalShelter[T_co: Animal]:
    def __init__(self, animal: T_co) -> None:
        self.animal = animal

def adopt_animal(box: AnimalShelter[Animal]) -> Animal:
    return box.animal

cat = Cat()
rescue_cat = AnimalShelter(cat) 
my_cat = adopt_animal(rescue_cat) # "AnimalShelter[Cat]" is incompatible with "AnimalShelter[Animal]"
 Type parameter "T_co@AnimalShelter" is invariant, but "Cat" is not the same as "Animal"

Because of inference, it deems AnimalShelter[Animal] to be invariant as self.animal is mutable. There are two ways to resolve this.

The first is by using typing.Final. This informs the type checker that the name cannot be re-assigned or overridden in a subclass.

from typing import Final

class Animal:
    pass

class Cat(Animal):
    pass

class AnimalShelter[T_co: Animal]:
    def __init__(self, animal: T_co) -> None:
        self.animal: Final = animal

The second, and the way I believe is more correct, is by making self._animal private and using a @property, essentially making it "read-only".

class Animal:
    pass

class Cat(Animal):
    pass

class AnimalShelter[T_co: Animal]:
    def __init__(self, animal: T_co) -> None:
        self._animal = animal
        
    @property
    def animal(self) -> Animal:
        return self._animal

def adopt_animal(box: AnimalShelter[Animal]) -> Animal:
    return box.animal

cat = Cat()
rescue_cat = AnimalShelter(cat) 
my_cat = adopt_animal(rescue_cat)

Final thoughts

Both approaches have their place and choosing which way you want to handle your generics in Python will essentially come down some key points.

Project and team scale: Larger, more complex projects might still benefit from the explicit nature of traditional generics, particularly for maintaining strict type control across large teams.
Codebase Maturity: Introducing new syntax in a mature codebase requires careful consideration, training, and potential refactoring. New projects have the freedom to adopt the latest features from the start.
Development Philosophy: Some teams prioritise using the latest Python features to keep their codebase modern and concise, while others value the stability and clarity brought by the established patterns.
Personal project: Use whatever you want.

Thanks for reading and if you wish to dig further into generics in Python check out the following resources:

https://peps.python.org/pep-0484/#generics

https://peps.python.org/pep-0695/

https://mypy.readthedocs.io/en/stable/generics.html