traversal in a bst

( Fri Oct 2, 2015 )

Traversal In A Binary Tree

To traverse a data structure means

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

When we traverse a binary tree we perform an operation once on each node. Performing the operation is called visiting the node. For example;
- If a company uses a binary tree 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 binary tree, 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 binary tree 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: If the binary tree is a binary search tree (BST) then in-order traversal visits the nodes in order of increasing key-value.
  - In-order traversal is useful for such things as printing out data in order by key.
  - Arithmetic expressions can be stored in binary trees in a convenient form. In-order traversal is useful for outputting the expressions in infix notation.
  - 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.
  - Arithmetic expressions can be stored in binary trees in a convenient form. Pre-order traversal is useful for outputting the expressions in prefix notation.
  - 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.
  - Arithmetic expressions can be stored in binary trees in a convenient form. Post-order traversal is useful for outputting the expressions in postfix notation.
  - 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 ;
}
```