Python Data Structures – Binary Trees

in

You might have heard that they’re complex and difficult to work with, but let me tell you something they’re not as scary as people make them seem! In fact, I’m going to break down this concept for you in a way that even your grandma could understand (if she knew how to use Python).

To start: what is a binary tree? Well, it’s basically just a fancy name for a list of values that are organized into pairs. Each pair consists of two elements let’s call them the “left” and “right” children. These kids can have their own sets of siblings (otherwise known as “cousins”), but we won’t worry about those for now.

Here’s an example:

# Define a binary tree with some values
tree = [1, 2, 3]

# Set the first value as the root of our tree
root = Node(tree[0]) # Create a node with the value of the first element in the tree list and assign it as the root of the tree

# Create nodes for each child and add them to their respective parents
Node(tree[1], parent=root) # Create a node with the value of the second element in the tree list and assign it as the left child of the root node
Node(tree[2], parent=root) # Create a node with the value of the third element in the tree list and assign it as the right child of the root node

Now, you might be wondering what’s the point of all this? Well, binary trees are incredibly useful when it comes to sorting data. Instead of having to compare every single value in a list (which can take forever for large datasets), we can use our tree structure to quickly find the smallest or largest element without having to do any unnecessary work.

Here’s an example: let’s say you have a list of numbers and you want to find the maximum value. Instead of looping through every single number, you could just start at the root node (which is always the biggest value) and follow the right child until you reach a leaf node (which has no more children).

# Define a binary tree with some values
tree = [10, 5, 20]

# Set the first value as the root of our tree
root = Node(tree[0]) # Create a Node object with the value of the first element in the tree list and assign it to the variable "root"

# Create nodes for each child and add them to their respective parents
Node(tree[1], parent=root) # Create a Node object with the value of the second element in the tree list and assign it as the left child of the root node
Node(tree[2], parent=root) # Create a Node object with the value of the third element in the tree list and assign it as the right child of the root node

# Define a function that finds the maximum value in a binary tree
def find_max(node):
    # If we've reached a leaf node (i.e., there are no more children), return its value
    if not node.right: # Check if the node has a right child, if not, it is a leaf node and we can return its value
        return node.data # Return the value of the leaf node
    
    # Otherwise, follow the right child until we reach a leaf node and return its value
    else:
        return find_max(node.right) # Recursively call the function with the right child of the current node until we reach a leaf node and return its value

And that’s it! With just a few lines of code, you can create a binary tree structure in Python and use it to sort data quickly and efficiently. So next time someone tells you that binary trees are too complicated for your grandma to understand, show them this article and prove them wrong!

SICORPS