Okay, picture this: a tree with branches, but instead of leaves, it has numbers and it's upside down. And the first number is called the root node. Use this image so I don't annoy you
Two numbers are branching from the root node
Those 2 branches form parent nodes other to other children
Let us use a more complex one
The numbers are not randomly arranged. On every branch, the value on the left is smaller than the one on the parent node and the value on the right is larger than the parent node.
And yes the first image of this article is not a valid binary tree.
You can create your own binary tree here to see how it works
Anyway, the binary tree is made that way to help for easy searching
As you search, the number of values you have to search through is divided in half. That is the secret to its speed!
Let us go straight to how we can implement this in python
I recommend you have decent knowledge in Object Oriented Programming (OOP) for this.
class Node:
def __init__(self, key):
self.left = None
self.right = None
self.val = key
class BST:
def __init__(self):
self.root = None
def insert(self, root, key):
if root is None:
return Node(key)
else:
if key < root.val:
root.left = self.insert(root.left, key)
else:
root.right = self.insert(root.right, key)
return root
def search(self, key):
if self.root is None or root.val == key:
return root
if self.root.val < key:
return self.search(self.root.right, key)
return self.search(self.root.left, key)
We have 2 classes
BST which stands for Binary Search Tree and Node which stands for .... node👍
When trying to add something to the tree, we make sure it follows the rules so that retrieving it is not a hassle. This is what the insert function, is trying to achieve
The search function is supposed to get any value that you're looking for in the binary tree (Recursively). This works similarly to how it is sorted when added.
# Create a BST instance
bst = BST()
# Insert elements
keys = [15, 10, 20, 8, 12, 17, 25]
for key in keys:
bst.root = bst.insert(bst.root, key)
search_value = 12
result_node = bst.search(bst.root, search_value)
if result_node:
print(f"Value {search_value} found in the tree!")
else:
print(f"Value {search_value} not found in the tree.")
This is just an example of how you can run the binary tree you just implemented and search for a value in it
Conclusion
In the realm of Binary Search Trees (BSTs), we've unveiled a powerful tool that balances simplicity and efficiency. With the rule of smaller left and larger right, BSTs enable lightning-fast data searches and structured organization.
In the tech world, BSTs shine as unsung heroes. They underpin search engines, database systems, and more at big tech companies. Their balance and speed drive the algorithms that power our digital interactions, making BSTs an essential foundation of modern technology.