Project 4: Ordered Sets

Educational Objectives: On successful completion of this assignment, the student should be able to

• Define the concept of associative container as a re-usable component in programs
• State the distinction between unimodal and multimodal associative containers, and:
  1. Give examples of each type
  2. Describe use cases making each type appropriate
• State the distinction between ordered and unordered associative containers
  1. Give examples of each type
  2. Describe use cases making each type appropriate
• Name the primary defining operations for associative containers of these types:
  1. Unimodal Ordered Set
  2. Multimodal Ordered Set (aka Ordered Multiset)
  3. Unimodal Unordered Set
  4. Multimodal Unordered Set (aka Unordered Multiset)
  5. Unimodal Ordered Map (aka Ordered Table)
  6. Multimodal Ordered Map (aka Ordered Multimap)
  7. Unimodal Unordered Map (aka Unordered Table)
  8. Multimodal Unordered Map (aka Unordered Multimap)
  9. Associative Array
  Describe the behavior and state the runtime expectations for each operation.
• Describe various implementation plans for ordered associative containers, and discuss whether and why runtime expectations are met by the implementation.
• Define "leggy" and "bushy" for a binary search tree (BST), and give examples to illustrate the concepts.
• Give and argument that red-black trees are always "bushy".
• Give complete details on implementing red-black binary trees
• Argue why and how red-black binary trees provide an implementation for ordered set, including runtime expectations for the principal operations
• Implement ordered set as red-black tree, including testing for functionality and structural integrity

Background Knowledge Required: Be sure that you have mastered the material in these chapters before beginning the project:
Binary Trees and Iterators, Binary Tree Construction, Associative Binary Trees, Generic Associative Containers, Set and Map Abstractions,

Operational Objectives: Implement a generic container class TRBT<T,P> based on the red-black tree algorithms for insertion and removal of elements and satisfying the conditions detailed in this document.

Deliverables: One file:

trbt.h      # contains the red-black tree definitions and implementations

Red-Black Trees

A red-black tree is a binary search tree whose nodes have a color attribute and which satisfies the following additional properties:

1. Every node color is either red or black
2. The root is black
3. If a node is red, then all its children are black
4. For each node N, all descending paths from N to a leaf have the same number of black nodes

Because a red-black tree (RBT) is a binary search tree (BST), there is a well defined binary search algorithm in an RBT that follows descending paths. An important feature of RBTs is that they have height bounded above by 2 log₂ (n + 1), where n is the number of nodes in the RBT, so an RBT must be fairly "bushy". (In stark contrast, a BST can be severely "leggy", with height n - 1. We can define "bushy" and "leggy" asymptotically as having height O(log n) and Ω(n), respectively.) It follows that

Theorem 1. BST search in an RBT has worst case run time is O(log n), where n is the number of nodes.

The challenge is to make sure that the RBT properties are maintained as we insert and remove elements. It turns out that the RBT properties do not necessarily hold after an ordinary BST insert or remove operation, but that there are "repair" algorithms that bring the resulting BST back into compliance with the RBT rules. These algorithms restructure the BST by pruning and re-hanging subtrees and are called rotations.

Rotations are constant time algorithms, and they are combined into repair algorithms that iterate along a descending path in the RBT. It follows that BST insert or remove, followed by RBT repair, has run time O(log n). Consequently

Theorem 2. RBT insert and remove have worst case run time O(log n).

Detailed specifications of the algorithms, including proof of correctness of the asserted outcomes, are found in the text [Cormen, Ch 13].

Procedural Requirements

1. Define and implement the classes TRBT<T,P> and TRBTIterator<T,P> in the file rbt.h. Also place all supporting definitions and implementations, such as operator overloads, in this file.

2. Test your classes using the distributed test harness fcset.cpp.

3. Write a brief description of your development and test methods and results and place this in the file header documentation of rbt.h.

4. Submit the project using the script LIB/submitscripts/proj4submit.sh.

Code Requirements and Specifications

1. T is the element type stored in the container.

2. P is the predicate type used to determine order in the container.

3. TRBT<T,P> should implement unimodal associative container semantics.

4. TRBTIterator<T,P> should implement const bidirectional iterator semantics.

5. TRBT<T,P> and TRBTIterator<T,P> should be in the fsu namespace.

6. TRBT<T,P> should use composition with TBinaryTree<T>, as illustrated in TBST<T,P> (distributed in the file LIB/tcpp/tbst.h).

7. TRBTIterator<T,P> should use composition with TBinaryTreeIterator<T>, as illustrated in TBSTIterator<T,P> (distributed in the file LIB/tcpp/tbst.h).

8. Create TRBT<T,P> as a derived class of TBST<T,P>. In this plan, a good bit of code can be re-used (by inheritance), including complete re-use of BSTIterator using a typedef statement. However there may be a small runtime penalty in some of the operations, not enough to affect the asymptotic runtime. The file tbst.h will be in the library to facilitate this plan.

   A big advantage of this plan is that there is a predefined testing method already implemented as part of TBST:

   void TestRBT () const;
   

   You may observe that following this requirement will automatically ensure that several of the earlier requirements are satisfied.

9. TRBT<T,P> should function correctly with the following definition of SetType:

   typedef fsu::CSet < T , fsu::TRBT < T , P > , P > SetType;
   

   That is, objects of type SetType should exhibit correct behavior for a unimodal ordered set of elements of type T and order predicate P as defined in the file cset.h and tested using fcset.cpp.

Hints

• Detailed understanding of the definition and implementation of TBinaryTree<T>, TBST<T,P> and their associated iterator and navigator classes will be both required and substantially helpful.

• There are only two operations (other than the usual mandatory constructors, destructor, and assignment operator) that require new or modified implementation from those in the parent class TBST<T,P> - the two associative mutation methods:

  Iterator  Insert (const ValueType&);
  size_t    Remove (const ValueType&);        
  

  These can be implemented using calls to base class methods of the same name or by going all the way back to calls to TBinaryTree<T> insertion and removal methods

  InsertRoot(t);
  InsertLeft(t)
  InsertRight(t)
  Remove(i)
  

  In either case, you will need to finish off an insertion or removal with a red-black repair process that rebalances the tree with calls to the TBinaryTree<T> rotation methods

  RotateLeft(n)
  RotateRight(n)
  

  and then resets the colors of nodes after the rotation.

• You may want to encapsulate the repair process with a couple of private methods

  InsertRestore (...);
  RemoveRestore (...);
  

  that are called after new node is inserted or removed from the tree.

• One implementation uses these precise prototypes and functional descriptions:

  void InsertRestore (const TBinaryTreeNavigator& n);
  // Called after inserting a new node n
  // Restores the tree to the RBT status
  
  void RemoveRestore
  (
    TBinaryTreeNavigator<T>& child,   // the child of the node to remove
    TBinaryTreeNavigator<T>& parent,  // the parent of the node to remove
    int left                          // whether the child is left or right
  )                                                                                           
  // Called before removing a node
  // Assumes the node to remove has at most one child
  // Restores the tree to the RBT status
  

• The functionality test program fcset.cpp will be used in our assessment. You may also find it useful to build up a simplifiued test harness as you develope TRBT.

• The structural integrity test program strbt.cpp will also be used in our assessment of TRBT.