top

COMP 202: Principles of Object-Oriented Programming II

← Tree Traversal Algorithms →

Home — Fall 2008

Mutable Binary Tree Framework

The Mutable Binary Tree Framework stores data in a hierarchical fashion, where mutation is allowed:

Source code
Documentation
Key Design Patterns:
- The Composite Pattern: for implementing the structure
- The Visitor Pattern: for decoupling the algorithms on the structure from the structure itself
- The State Pattern: for implementing dynamic re-classification, allowing transparent state dependent behavioral changes.

Tree Traversals

When we process a list, we basically have two ways to traverse it and move data along: forward (as in forward accumulation) or reverse (as in reverse accumulation). In contrast, due to its non-linear structure, a binary tree can be traversed in many more different ways. However, we can categorize data movement in two "directions": top-down and bottom-up. In this lecture, we will study four tree traversal algorithms that are most common in tree processing.

In order traversal
Pre order traversal
Post order traversal
Breadth-first traversal

For the sake of definiteness, we consider the following trees as examples throughout:

mtTree: an empty tree

biTree: the non-empty tree

               1
            /     \
         2         3
      /    \          \
    4      5           6
                       /
                    7

In Order Traversal

Here is what it means to process a tree by traversing it in in order.

For an empty tree:
- Do whatever is appropriate for the problem
For a non-empty tree:
- Process the left subtree by traversing it in in order; (note the recursive definition here)
- Process the root; (the root is processed in between the processing of the left and right subtrees)
- Process the right subtree by traversing it in in order; (not the recursive definition here)

Here is a concrete example of an in-order traversal of the above biTree.

In class Exercise 1:

Write a visitor that prints the contents of a binary in in-order traversal. What should the output be for the above biTree?

As you can see, there is so much similarity between the code for exercise 1 and InOrderAdd. The question is whether or not we can separate the variants from the invariant and capture the abstraction of in-order traversal as the invariant.

Clearly, tree traversal is a visitor. What does it mean to "process the root"? How can we enforce the order of processing?

Processing the root and each of the subtrees: use an abstract function ILambda; the concrete ILambdas are the variants.

Enforcing the order of processing: use the order in which the arguments of of a function are evaluated; this is the invariant.

So here is the invariant code for in-order tree traversal.

package brs.visitor;

import brs.*;
import fp.*;

/**
 * 
 * Traverse a binary tree in order:
 * For an empty tree:
 * do the appropriate processing.
 * For a non-empty tree:
 * Traverse the left subtree in order;
 * Process the root;
 * Traverse the right subtree in order;
 * 
 * Uses 3 lambdas as variants.
 * Let fRight, fLeft, fRoot be ILambda and b be some input object.
 *
 * empty case: 
 *   InOrder3(empty, fRight, fRoot, fLeft, b) = b;
 *
 * non-empty case: 
 *   InOder(tree, fRight, fRoot, fLeft, b) = 
 *     fRight(InOrder3(tree.right, fRight, fRoot, fLeft, b),
 *            fRoot(tree, 
 *                  fLeft(InOrder3(tree.left, fRight, fRoot, fLeft, b), b),
 *                  b),
 *            b);
 *
 * @author DXN
 * @author SBW
 * @author Mathias Ricken - Copyright 2008 - All rights reserved.
 * @since 09/22/2004
 */

public class InOrder3<T,P> implements IVisitor<T,P,P> {
    // binary function: <value from recursion to left>, b[0]
    private ILambda2<P,P,P> _fLeft;

// ternary function: <value from _fLeft>, tree, b[0]
    private ILambda3<P,P,BiTree<T>,P> _fRoot;
    
    // ternary function: <value from _fRoot>, <value from recursion to right>, b[0]
    private ILambda3<P,P,P,P> _fRight;  
    
    public InOrder3(ILambda3<P,P,P,P> fRight, ILambda3<P,P,BiTree<T>,P> fRoot, ILambda2<P,P,P> fLeft) {
        _fRight = fRight;
        _fLeft = fLeft;
        _fRoot = fRoot;
    }
    
    public P emptyCase(BiTree<T> host, P... b) {
        return b[0]; 
    }
    
    public P nonEmptyCase(BiTree<T> host, P... b) {
        return _fRight.apply(_fRoot.apply(_fLeft.apply(host.getLeftSubTree().execute(this, b), 
                                                       b[0]),
                                          host,
                                          b[0]),
                             host.getRightSubTree().execute(this, b),
                             b[0]);
    }
    
    public static void main(String[] nu) {
        
        ILambda2<Integer,Integer,Integer> passThruInt =
            new ILambda2<Integer,Integer,Integer>() {
            public Integer apply(Integer arg1, Integer ignored) {
                return arg1;
            }
        };
        
        ILambda3<Integer,Integer,BiTree<Integer>,Integer> addToRoot =
            new ILambda3<Integer,Integer,BiTree<Integer>,Integer>() {
            public Integer apply(Integer arg1, BiTree<Integer> arg2, Integer ignored) {
                return arg1+arg2.getRootDat();
            }
        };
        
       ILambda3<Integer,Integer,Integer,Integer> addToRight =
            new ILambda3<Integer,Integer,Integer,Integer>() {
            public Integer apply(Integer arg1, Integer arg2, Integer ignored) {
                return arg1+arg2;
            }
        };
         
        // Add the numbers in the tree in in-order fashion:
        InOrder3<Integer,Integer> inOrderAdd =
            new InOrder3<Integer,Integer>(addToRight, addToRoot, passThruInt);
        
        ILambda2<String,String,String> passThruStr =
            new ILambda2<String,String,String>() {
            public String apply(String arg1, String ignored) {
                return arg1;
            }
        };

final ILambda3<String,String,String,String> concat =
            new ILambda3<String,String,String,String>() {
            public String apply(String arg1, String arg2, String ignored) {
                if ("" != arg1.toString()) {
                    if ("" != arg2.toString()) {
                        return arg1.toString() + " " + arg2.toString();
                    }
                    else {
                        return arg1.toString();
                    }
                }
                else {
                    return arg2.toString();
                }
            }
        };
        
        ILambda3<String,String,BiTree<Integer>,String> concatToRoot =
            new ILambda3<String,String,BiTree<Integer>,String>() {
            public String apply(String arg1, BiTree<Integer> arg2, String ignored) {
                System.err.println(arg2.getRootDat());
                return concat.apply(arg1, arg2.getRootDat().toString(), ignored);  
            }
        };
        
        
        // Concatenate the String representation of the elements in the tree 
        
        // in in-order fashion:
        
        InOrder3<Integer,String> inOrderConcat = new InOrder3<Integer,String>(concat, concatToRoot, passThruStr);
        
        BiTree<Integer> bt = new BiTree<Integer>();
        System.out.println(bt + "\nAdd \n" + bt.execute(inOrderAdd, 0));
        System.out.println("In order concat \n" + bt.execute(inOrderConcat, "")); 
        System.out.println("==============================");
        
        bt.insertRoot(5);
        System.out.println(bt + "\nAdd \n" + bt.execute(inOrderAdd, 0));
        System.out.println("In order concat \n" + bt.execute(inOrderConcat, ""));  
        System.out.println("==============================");
        
        bt.getLeftSubTree().insertRoot(-2);
        System.out.println(bt + "\nAdd \n" + bt.execute(inOrderAdd, 0));
        System.out.println("In order concat \n" + bt.execute(inOrderConcat, ""));    
        System.out.println("==============================");
        
        bt.getRightSubTree().insertRoot(10);
        System.out.println(bt + "\nAdd \n" + bt.execute(inOrderAdd, 0));
        System.out.println("In order concat \n" + bt.execute(inOrderConcat, "")); 
        System.out.println("==============================");
        
        bt.getRightSubTree().getLeftSubTree().insertRoot(-9);
        System.out.println(bt + "\nAdd \n" + bt.execute(inOrderAdd, 0));
        System.out.println("In order concat \n" + bt.execute(inOrderConcat, ""));                
    }
}

Post Order Traversal

Here is what it means to process a tree by traversing it in in order.

For an empty tree:
- Do whatever is appropriate for the problem
For a non-empty tree:
- Process the left subtree by traversing it in in order; (note the recursive definition here)
- Process the right subtree by traversing it in in order; (not the recursive definition here)
- Process the root; (the root is processed last, after processing the left and right subtrees).

In class exercise 2:

Write an invariant post order traversal visitor analogous to the above in order traversal visitor.

Pre Order Traversal

Here is what it means to process a tree by traversing it in in order.

For an empty tree:
- Do whatever is appropriate for the problem
For a non-empty tree:
- Process the root; (the root is processed first, before processing the left and right subtrees).
- Process the left subtree by traversing it in in order; (note the recursive definition here)
- Process the right subtree by traversing it in in order; (not the recursive definition here)

In class exercise 2:

Write an invariant pre order traversal visitor analogous to the above in order traversal visitor.

← Tree Traversal Algorithms →