Learn Binary Trees in Python

Binary trees are a core concept in computer science, forming the foundation for numerous data structures like Binary Search Trees, Heaps, and more. They are widely used in applications such as hierarchical data representation, search operations, and parsers.

In this blog, we’ll explore a basic implementation of a binary tree in Python and build a simple tree structure with it.

What is a Binary Tree?

A binary tree is a hierarchical data structure in which each node has at most two children:

Left Child
Right Child

This structure allows for efficient data storage, retrieval, and traversal. Binary trees are extensively used in various algorithms and systems.

Code Walkthrough

Here is a simple implementation of a binary tree in Python.

Node Class
```
 class Node:

     def __init__(self, data):
         self.data = data
         self.left = None
         self.right = None
```
Explanation:
- Attributes:
  - data: Stores the value of the node.
  - left: Points to the left child of the node (initially None).
  - right: Points to the right child of the node (initially None).
- Constructor:
  - Initializes the node with the given data and sets the left and right references to None.
BinaryTree Class
```
 class BinaryTree:

     def __init__(self, data):
         self.root = Node(data)
```
Explanation:
- Attributes:
  - root: Points to the root node of the tree.
- Constructor:
  - Initializes the tree with a root node containing the specified data.

Main Function

 if __name__ == "__main__":

     tree = BinaryTree(1)
     tree.root.left = Node(2)
     tree.root.right = Node(3)
     tree.root.left.left = Node(4)
     tree.root.left.right = Node(5)
     tree.root.right.left = Node(6)
     tree.root.right.right = Node(7)

Steps:

Create the Binary Tree:
- A new tree is created with 1 as the root node.
Add Child Nodes:
- The left and right children of the root are set to 2 and 3, respectively.
- Additional nodes are added to form the following tree structure:
```
           1
         /   \
        2     3
       / \   / \
      4   5 6   7
```

Visualizing the Tree

The above code creates the binary tree as follows:

         1
       /   \
      2     3
     / \   / \
    4   5 6   7

Each node points to its left and right children, forming the binary tree structure.

Applications of Binary Trees

Data Storage:
- Used in databases and file systems to store hierarchical data.
Efficient Searching:
- Binary Search Trees (BST) enhance search operations with a time complexity of O(log⁡n)O(\log n)O(logn).
Expression Parsing:
- Represent mathematical expressions in parsers and compilers.
Network Routing:
- Binary trees help in constructing efficient routing paths.

Extending the Implementation

While the current implementation is static, you can extend it by:

Adding traversal methods (e.g., In-order, Pre-order, Post-order).
Implementing methods for dynamic insertion and deletion.
Exploring other types of trees, such as Binary Search Trees or AVL Trees.

Conclusion

This blog introduces the basics of binary trees in Python. By building and visualizing a simple tree, we’ve established a solid foundation for understanding more advanced tree-based data structures.

Binary trees are versatile tools in software engineering. Mastering their implementation opens the door to numerous practical applications.

Happy coding! 😊

References

Find the code for the above explanation here.

Introduction to Binary Trees in Python

Understanding the Basics of Binary Trees in Python: A Step-by-Step Guide

Table of contents