traversal in a bst

(Latest Revision: 03/30/2008)

Traversal In A BST

To traverse a data structure means

to perform some operation once on each component part of the data structure.

When we traverse a BST we perform an operation once on each node. Performing the operation is called visiting the node. For example;
- If a company uses a BST to store employee information, a program computing the monthly payroll might traverse the tree. For each node visited the program might look at the employee information stored there, figure the salary due to the employee, and place an order to 'cut' a paycheck.
- It might be the job of a program to input a BST, and output a diagram of the tree. Such a program might perform its task by traversing the tree and drawing a 'picture' of each node in the tree.
- The destructor of a BST might employ a traversal. When each node is visited the destructor could 'pluck' (delete) the node from the tree and deallocate its memory.
One can list 3 objects (ABC) in six different orders: (ABC), (ACB), (BAC), (BCA), (CAB), and (CBA). In general one can list N objects in N! different orders. So if a tree contains N nodes there are N! possible traversal orders. Here is a list of three traversal orders that are frequently used:
- In-Order Traversal visits the nodes in order of increasing key-value.
  - In-order traversal is useful for such things as printing out the data in order by key.
  - Reverse in-order traversal is useful for printing diagrams of binary trees.
  - Here is a nice compact recursive algorithm for in-order traversal:
```
if (the tree is not empty)
{
  Do (recursively) an in-order traversal
    of the left sub-tree of the root ;

  Visit the root node ;

  Do (recursively) an in-order traversal
     of the right sub-tree of the root ;
}
```
- Pre-Order Traversal visits each node only after visiting all its ancestors.
  - Pre-order traversal is useful for making a copy of a binary tree.
  - Here is a nice compact recursive algorithm for pre-order traversal:
```
if (the tree is not empty)
{
  Visit the root node ;

  Do (recursively) a pre-order traversal
    of the left sub-tree of the root ;

  Do (recursively) a pre-order traversal
     of the right sub-tree of the root ;
}
```
- Post-Order Traversal visits each node only after visiting all its descendants.
  - Post-order traversal is useful for implementing the destructor of a binary tree.
  - Here is a nice compact recursive algorithm for post-order traversal:
```
if (the tree is not empty)
{
  Do (recursively) a post-order traversal
    of the left sub-tree of the root ;

  Do (recursively) a post-order traversal
     of the right sub-tree of the root ;

  Visit the root node ;
}
```