Search trees are everywhere: In databases, in file systems, in board game algorithms,… This post explores the probably most basic form of a tree: a binary search tree.
The Problem
Searching a value in a linear data container (list, array) with n elements can take up to n steps. Click on “Play” in the animation below and see how many steps it takes to find the value “3” when this value is in the last element of a list container.
Computer scientists say that this operation has an order of O(n) . For very large values of n , this operation can become quite slow. Can we do better?
The Solution
If the data is organized in a tree structure, access can be much faster. Rather than 6 steps in the above example, the search takes only two steps:
The secret is that there is a sort order in this data structure. The search value is first compared against the value at the top of this structure. If the search value is smaller, the search continues with the next value to the left; else it continues with the next value to the right. Repeat until the value is found, or until there are no more values to the left or the right of the current value.
Binary Search Tree Basics
But wait, what is this “tree structure” seen in the animation above? This structure is called a binary search tree . It has the following properties:
 A tree consists of nodes that store unique values.
 Each node has zero, one, or two child nodes.
 One of the nodes is designated as the root node that is at the top of the tree structure. (This is the “entry point” where all operations start.)
 Each node has exactly one parent node, except for the root node, which has no parent.
 Each node’s value is larger than the value of its left child but larger than the value of its right child.
 Each subtree to the left of a node only contains values that are smaller than the node’s value, and each subtree to the right of a node contains only larger values.
Some quick definitions that help keeping the following text shorter:
 A node with no children is called a leaf node .
 A node with one child is called a half leaf node .
 A node with two children is called an inner node .
 The longest path from the root node to a leaf node is called the tree’s height .
In the best case, the height of a tree with n elements is log2(n+1) (where “log2” means the logarithm to base 2). All paths from the root node to a leaf node would have roughly the same length (plus/minus one). The tree is called a “balanced tree” in this case. Operations on this tree would have an order of *O(log(n)).
For large values of n , the logarithm of n is much smaller than n itself, which is why algorithms that need O(log(n)) time are much faster on average than algorithms that need O(n) time.
Take a calculator and find it out!
Let’s say we have 1000 elements in our data store.
If the data store is a linear list, a search needs between 1 and 1000 steps to find a value. On average, this would be about 500 steps per search (if we assume the data is randomly distributed in this list).
If the data store is a balanced tree, a search needs at most log2(1001), or roughly 10 steps. What an improvement!
To visualize the difference, here is a diagram with a linear graph (in red) and a logarithmic graph (in blue). As the value on the x axis  the size of the data set  increases, the linear function keeps increasing with the same rate while the logarithmic function increases slower and slower the larger x gets.
Remember, O(log(n)) is only for the best case, where the tree is balanced, and no path to a leaf node is particularly longer than any other path.
In this post, however, we look at a very simple binary search tree. Especially, we do not care to minimize the height of the search tree. So in the worst case, a tree with n elements can have a height of n , which means it is not better than a linear list. In fact, in this case, the tree is effectively a linear list:
So in the tree that we are going to implement, a search would take anywhere between O(log(n)) and O(n) time. In the next article, we’ll see how to ensure that the tree is always balanced, so that a search always takes only O(log(n)) time.
Today’s code: A simple binary search tree
Let’s go through implementing a very simple search tree. It has three operations: Insert, Delete, and Find. We also add a Traverse function for traversing the tree in sort order.
Imports and globals
package main import ( "errors" "fmt" "log" )
A Tree Node
Base on the above definition of a binary tree, a tree node consists of * a value, * a left subtree, and * a right subtree.
By the way, this is a recursive data structure: Each subtree of a node is also a node containing subtrees.
In this minimal setup, the tree contains simple string data.
Node
contains the search value, some data, a left child node, and a right child node.
type Node struct { Value string Data string Left *Node Right *Node }
Node Operations
Insert
To insert a value into a sorted tree, we need to find the correct place to add a new node with this value. Here is how:
 Start at the root node.
 Compare the new value with the current node’s value.
 If it is the same, stop. We have that value already.
 If it is smaller, repeat 2. with the left child node. If there is no left child node, add a new one with the new value. Stop.
 IF it is greater, repeat 2. with the right child node, or create a new one if none exists. Stop.
Sounds quite easy, doesn’t it? Just keep in mind we do not take care of keeping the tree balanced. Doing so adds a bit of complexity but for now we don’t care about this.
The Insert method we define here works recursively . That is, it calls itself but with one of the child nodes as the new receiver. If you are unfamiliar with recursion, see the little example here or have a look at this factorial function .
Insert
inserts new data into the tree, at the position determined by the search value. Return values:

true
if the data was successfully inserted, 
false
if the data value already exists in the tree.
func (n *Node) Insert(value, data string) error { if n == nil { return errors.New("Cannot insert a value into a nil tree") } switch {
If the data is already in the tree, return.
case value == n.Value: return nil
nil
, insert a new left child node. Else call
Insert
on the left subtree.
case value < n.Value: if n.Left == nil { n.Left = &Node{Value: value, Data: data} return nil } return n.Left.Insert(value, data)
case value > n.Value: if n.Right == nil { n.Right = &Node{Value: value, Data: data} return nil } return n.Right.Insert(value, data) } return nil }
Find
Finding a value works as seen in the second animation of this article. (Hence, no animation here.) The Find method is also recursive. It returns either the data of the found node and true
, or “” and false
if the node is not found.
Find
searches for a string. It returns:
 The data associated with the value and
true
, or  ”” and
false
if the search string is not found in the tree.
func (n *Node) Find(s string) (string, bool) { if n == nil { return "", false } switch {
If the current node contains the value, return the node.
case s == n.Value: return n.Data, true
Find
for the left child node,
case s < n.Value: return n.Left.Find(s)
Find
for the right child node.
default: return n.Right.Find(s) } }
Delete
Deleting a value is a bit more complicated. Or rather, it is easy for two cases, and complicated for the third.
The easy cases:
Delete a leaf node.
This one is dead simple: Just set the parent’s pointer to the node to nil.
Delete a halfleaf node.
Still easy: Replace the node by its child node. The tree’s order remains intact.
The complicated case:
Delete an inner node.
This is the interesting part. The node to be deleted has two children, and we cannot assign both to the deleted node’s parent node. Here is how this is solved. For simplicity, we assume that the node to be deleted is the right child of its parent node. The steps also apply if the node is the left child; you only need to swap “right” for “left”, and “large” for “small”.
 In the node’s left subtree, find the node with the largest value. Let’s call this node “Node B”.
 Replace the node’s value with B’s value.
 If B is a leaf node or a halfleaf node, delete it as described above for the leaf and halfleaf cases.
 If B is an inner node, recursively call the Delete method on this node.
The animation shows how the root node is deleted. This is a simple case where “Node B” is a halfleaf node and hence does not require a recursive delete.
To implement this, we first need two helper functions. The first one finds the maximum element in the subtree of the given node. The second one removes a node from its parent. To do so, it first determines if the node is the left child or the right child. Then it replaces the appropriate pointer with either nil (in the leaf case) or with the node’s child node (in the halfleaf case).
findMax
finds the maximum element in a (sub)tree. Its value replaces the value of the tobedeleted node. Return values: the node itself and its parent node.
func (n *Node) findMax(parent *Node) (*Node, *Node) { if n.Right == nil { return n, parent } return n.Right.findMax(n) }
replaceNode
replaces the
parent
’s child pointer to
n
with a pointer to the
replacement
node.
parent
must not be
nil
.
func (n *Node) replaceNode(parent, replacement *Node) error { if n == nil { return errors.New("replaceNode() not allowed on a nil node") } if n == parent.Left { parent.Left = replacement } parent.Right = replacement return nil }
Delete
removes an element from the tree. It is an error to try deleting an element that does not exist. In order to remove an element properly,
Delete
needs to know the node’s parent node.
parent
must not be
nil
.
func (n *Node) Delete(s string, parent *Node) error { if n == nil { return errors.New("Value to be deleted does not exist in the tree") }
Search the node to be deleted.
switch { case s < n.Value: return n.Left.Delete(s, n) case s > n.Value: return n.Right.Delete(s, n) default:
if n.Left == nil && n.Right == nil { n.replaceNode(parent, nil) return nil }
If the node has one child: Replace the node with its child.
if n.Left == nil { n.replaceNode(parent, n.Right) return nil } if n.Right == nil { n.replaceNode(parent, n.Left) return nil }
replacement, replParent := n.Left.findMax(n)
n.Value = replacement.Value n.Data = replacement.Data
Then remove the replacement node.
return replacement.Delete(replacement.Value, replParent)
}
}
The Tree
One of a binary tree’s nodes is the root node  the “entry point” of the tree.
The Tree data type wraps the root node and applies some special treatment. Especially, it handles the cases where the tree is completely empty or consists of a single node.
The Tree data type also provides an additional function for traversing the whole tree.
Tree
basically consists of a root node.
type Tree struct { Root *Node }
Insert
calls
Node.Insert
unless the root node is
nil
func (t *Tree) Insert(value, data string) error {
If the tree is empty, create a new node,…
if t.Root == nil { t.Root = &Node{Value: value, Data: data} return nil }
Node.Insert
.
return t.Root.Insert(value, data)
}
Find
calls
Node.Find
unless the root node is
nil
func (t *Tree) Find(s string) (string, bool) { if t.Root == nil { return "", false } return t.Root.Find(s) }
Delete
has one special case: the empty tree. (And deleting from an empty tree is an error.) In all other cases, it calls
Node.Delete
.
func (t *Tree) Delete(s string) error { if t.Root == nil { return errors.New("Cannot delete from an empty tree") }
Node.Delete
. Passing a “fake” parent node here avoids having to treat the root node as a special case.
fakeParent := &Node{Right: t.Root} return t.Root.Delete(s, fakeParent) }
Traverse
is a simple method that traverses the tree in lefttoright order (which,
by pure incidence ;), is the same as traversing from smallest to largest value) and calls a custom function on each node.
func (t *Tree) Traverse(n *Node, f func(*Node)) { if n == nil { return } t.Traverse(n.Left, f) f(n) t.Traverse(n.Right, f) }
A Couple Of Tree Operations
Our main
function does a quick sort by filling a tree and reading it out again. Then it searches for a particular node. No fancy output to see here; this is just the proof that the whole code above works as it should.
main
func main() {
Set up a slice of strings.
values := []string{"d", "b", "c", "e", "a"} data := []string{"delta", "bravo", "charlie", "echo", "alpha"}
Create a tree and fill it from the values.
tree := &Tree{} for i := 0; i < len(values); i++ { err := tree.Insert(values[i], data[i]) if err != nil { log.Fatal("Error inserting value '", values[i], "': ", err) } }
Print the sorted values.
fmt.Print("Sorted values:  ") tree.Traverse(tree.Root, func(n *Node) { fmt.Print(n.Value, ": ", n.Data, "  ") }) fmt.Println()
Find values.
s := "d" fmt.Print("Find node '", s, "': ") d, found := tree.Find(s) if !found { log.Fatal("Cannot find '" + s + "'") } fmt.Println("Found " + s + ": '" + d + "'")
Delete a value.
err := tree.Delete(s) if err != nil { log.Fatal("Error deleting "+s+": ", err) } fmt.Print("After deleting '" + s + "': ") tree.Traverse(tree.Root, func(n *Node) { fmt.Print(n.Value, ": ", n.Data, "  ") }) fmt.Println() }
The code is on GitHub. Use d
on go get
to avoid installing the binary into $GOPATH/bin.
go get d github.com/appliedgo/bintree cd $GOPATH/src/github.com/appliedgo/bintree go build ./bintree
Conclusion
Trees are immensely useful for searching and sorting operations. This article has covered the most basic form of a search tree, a binary tree. Other variations of trees exist (and are widely used), for example, trees where nodes can have more than two children, or trees that store data in leaf nodes only. None of these variations are inherently better; each has its particular use case(s).
You surely have noticed that most of the methods used here are written in a recursive manner. To keep your fingers exercised, rewrite those methods without using recursion.
Find out more about binary search trees on Wikipedia .
In the next article on binary trees, we will see how to keep the tree balanced, to achieve optimal search performance.
Until then!