C++ Notes: Binary Search Trees

O(log N) can be MUCH better than O(N)

For large values of N, differences in efficiency are dramatic. For example, a linear search of an array requires n/2 comparisons on the average. If the array is sorted, it's possible to do a binary search with an average of log base 2 comparisons. For small values of n this is not an important difference. For example, for 32 items it takes 16 comparisons for linear search vs 5 for a binary search. The extra 11 comparisons are negligible.

In contrast to this, if n is a million, a linear search requires 500,000 comparisons vs 20 comparisons for binary search. This is significant, but there are other issues. For example, inserting or deleting in a sorted list is an O(N) operation because, on the average, half of the elements that have to be moved, so for frequent updates there is much less advantage to a sorted array. Binary search is also not possible on a linked list because random access is required.

Binary search trees: O(log N) search and insert

Because insertion in a tree is a matter of changing links and not moving data, binary search trees have the speed advantages of sorted arrays for searching plus fast inserting (O(log n) to find the insertion point and O(1) to insert). A fairly well balanced tree can be maintained with so-called red-black trees.

Typical binary tree node

struct tree_node {
    tree_node *left;   // left subtree has smaller elements
    tree_node *right;  // right subtree has larger elements
    int data;

Standard Template Library uses binary search trees

Binary search trees are so good, they are the underlying implementation for the STL map, multimap, set, and multiset.

Related Pages

Next: Binary Tree Traversal.