Binary tree is one of the most important data structures in the programming world. The basic definition can be given as follows (as mentioned in one of the data structures book by Tenenbaum). "A binary tree is a finite set of elements that is either empty or is partitioned into three disjoint subsets. The first subset contains a single element called root of the tree. The other two subsets are themselves binary trees, called left and right sub trees of the original tree. A left or right sub tree can be empty and each element off the binary tree is called as the node." The definition itself is recursive in nature and might sound cryptic. This diagram would make this more clear.
There are countless variations to the basic the Binary tree defined and each of these have various applications. For example, the Heap is an implementation of the binary tree. Various low level data structures of the file system and databases would be a heap. This list just goes on...
Implementing a binary tree
In this article we shall see a very simple binary tree implementation. In terms of implementation, a binary tree is a type of a linked list of nodes. So, let's see how a node can be defined:
Public Value As Object
Public LeftNode As TreeNode
Public RightNode As TreeNode
Here, I have a class called
TreeNode with members
RightNode to point to a left and right sub tree respectively, and
Value which is type
Object (can hold anything). I really would have liked a structure to represent a node instead of a class (like in those C days), but in VB.NET, a structure cannot contain a member of its own type.
Creating a tree itself, again, is pretty simple. First, you create the root and then create the right and left sub trees. In our example, we create a simple tree of integers generated randomly. Let's see how this is done.
We represent the
Tree as a class which exposes several methods to operate on it. Note that the root of the tree is made private and the only way to operate on the tree is through methods exposed by the
Public Class Tree
Private _root As TreeNode
To create a new tree, we create a new node in the class constructor and mark it as the root.
Sub New(ByVal rootValue As Object)
_root = GetNode(rootValue)
Private Function GetNode(ByVal value As Object) As TreeNode
Dim node As New TreeNode()
node.Value = value
Adding nodes to the tree
Adding a node to a tree is a bit more involved effort as a node can fit in one and only one place in a tree after a root is in place. We need to start with the root and compare the value of the root with the node's value. If the node value is smaller, then it goes to left sub tree and if it is greater, then it forms a part of the right sub tree. These comparisons happen all the way to the bottom of the tree, where we cannot proceed any further. At this point, one final comparison is made and the node is added to the final node's left or right sub tree. In my implementation, I dont support duplicate nodes. If in the process of adding a node, if its value is equal to node being compared, it is not added to the tree. Here's the code snippet:
Public Sub AddtoTree(ByVal value As Object)
Dim currentNode As TreeNode = _root
Dim nextNode As TreeNode = _root
While currentNode.Value <> value And Not nextNode Is Nothing
currentNode = nextNode
If nextNode.Value < value Then
nextNode = nextNode.RightNode
nextNode = nextNode.LeftNode
If currentNode.Value = value Then
Console.WriteLine("Duplicate value (" & _
value & "). Node was not inserted")
ElseIf currentNode.Value < value Then
currentNode.RightNode = GetNode(value)
currentNode.LeftNode = GetNode(value)
Note that in the above sample, I am making comparisons directly on the node value itself. This is under the assumption that all my nodes represent simple integers. Ideally, we should have a
Key for each node and the comparisons should happen on this field. In terms of implementation, this
Key object should implement
IComparable interface so that the tree can be of any type of object (the comparison would be transparent).
Traversing the tree
Traversing a tree involves visiting all the nodes in the tree. There are three ways you can achieve this:
- Post Order Traversal
- Pre Order Traversal
- In Order Traversal
Each of these approaches is very useful and has its own applications. In our sample, we shall consider Inorder traversal. This is a recursive process as explained below:
- Traverse the left sub tree
- Visit the root
- Traverse the right subtree
The significance of this traversal is that we visit all the nodes in a sorted fashion. So, in our case, we shall obtain the sorted list of integers by just traversing in order!
Private Sub inOrderTraverse(ByVal node As TreeNode)
If Not node Is Nothing Then
Here's a sample output:
In this article, we saw how a simple binary tree could be implemented with ease using VB.NET. Guys from the C world would notice that
free were not used used here. This is because I have left it to the .NET runtime to worry about allocation and collection (that's the best part)
I kept this article very simple by not considering more involved operations like Delete and Enumeration. Also, the very notion of Binary tree opens countless avenues in terms of algorithms and implementations. I would really like to write many articles involving these algorithms in the near future!