A printable PDF is available.

# Assignment 2 - Due Monday, October 3 at Noon

**Note:** This assignment has an unusual deadline, which is not
on a class day. Your first exam is on Tuesday, October 4, and I don't
want you to have to choose between a last minute push to complete this
assignment and studying for the exam. I would still encourage you to
try to get this finished by the preceding Friday, at the latest.

**Objectives:** There are three objectives for this assignment:

- Master details of red-black tree insertion
- Get further practice writing recursive functions on trees
- Learn about basic experimental analysis and profiling

**Background:**
Insertion into a red-black tree can either be done with bottom-up tree
balancing, as described in Section 19.5.1, or with top-down tree
adjustments, as described in Section 19.5.2. The code in the book uses
the top-down method, which is nice because all tree adjustments are
done in a single pass down the tree when searching for the insertion
point. In contrast, the bottom-up balancing requires two passes: one
down the tree to find the insertion point, and then a pass back up the
tree for adjusting the tree. However, the bottom-up approach makes
some applications of red-black trees much easier, so it's worth
considering this approach further. We can simplify the bottom-up
method (and avoid recursion) by including a "parent" pointer in each
node, allowing us to easily move up the tree as well as down.

Here's the technique in a nutshell: Do a standard unbalanced binary search tree insertion first, and color the new node red. After just the insertion of the new red node into a non-empty red-black tree, it's clear that all red-black tree properties are still satisfied, with the possible exception of property 3 (page 715). In other words, if the parent of the new node is also red, then we have just created a red child of a red node, which is not allowed (call this a "red-red violation"). If we have a red-red violation, we can correct it at this position with a rotation (single or double), as described in Section 19.5.1, which may create a single red-red violation higher in the tree. If there's a new violation, we move up the tree and repeat this process, continuing up the tree until there are either no more violations or we reach the root. If the algorithm goes all the way up the tree to the root, there is a possibility that the root is changed to a red node -- in that case, it should simply be recolored black so that red-black tree property 2 is satisfied. More details on this are in the textbook, and we will discuss it thoroughly in class.

**What To Do:** Start with the code in Bitbucket, as in previous
assignments: fork the "Assign2" repository, rename it to include
your username, grant read access to the class administrators, and then
use NetBeans on your computer to clone it so you can work with
it. This NetBeans project contains the full unbalanced binary search
tree implementation (from Section 19.1), the full top-down red-black
tree implementation (from Section 19.5), and an incomplete class
`AltRedBlackTree`

that is the start of a bottom-up rebalancing
implementation. I have slightly modified this code so that the
`RedBlackTree`

and `AltRedBlackTree`

are subclasses of the
`BinarySearchTree`

class, so that operations that don't depend on
the rebalancing operations on red-black trees can be done by generic
code that will work for all binary search trees (operations such as
the finding keys, counting numbers of nodes, etc.). In object-oriented
design terminology this is a good way to organize these classes,
since a `RedBlackTree`

IS-A `BinarySearchTree`

with some
additional functionality for maintaining the red-black balance properties.

Your first task is to study the book's red-black tree implementation, along with the explanation in the book, and make sure you completely understand it. Then you should do the following:

- Finish the implementation of the
`AltRedBlackTree`

class for the bottom-up rebalancing technique. Note that the node definition in this class (`AltRBNode`

) includes a parent pointer, as described above. The basic insertion routine is provided, and you need to write the`adjustTree()`

method that does the bottom-up rebalancing. Make sure you test your implementation thoroughly, which will require writing some internal testing procedures (some basic tests are provided in the`main`

method in the`AltRedBlackTree`

class, although this probably isn't enough to test everything - you can run this`main`

function by selecting the file in the projects pane of NetBeans, right clicking and selecting "Run File"). - The main project class,
`Assign2`

, includes code to print out statistics about the tree, but you will need to implement a few new methods in the`BinarySearchTree`

class:`getSize()`

,`getHeight()`

, and`getInternalPathLength()`

. [*Hint: See Figures 18.19 and 18.21 in the book.*] - Once you are confident that your tree implementation and
statistics methods are working correctly, run the main
program in the
`Assign2`

class, which will builds trees and prints out statistics about the trees that these implementations build. This will run six tests: each of the three implementations is run once with randomly ordered insertions, and once with insertions in sorted order. - NetBeans has a built-in profiler that will measure how much time each of the testing methods takes to build its tree, and you should use this to get a feel for the real-world timing of these implementations. Specific instructions on how to run the profiler and interpret the results are on the class web site. When the run completes, make sure you take a snapshot of the results, and then do a "Save Snapshot to Project" to store the results (do this before you commit your files and push to upstream!).

*Hint:* Note that some of the internal methods from the
provided `RedBlackTree`

class can be used either directly or with
small changes (especially the various rotation methods). You can cut
and paste these into the `AltRedBlackTree`

class as a starting
point. The biggest change you'll need to make to the rotation
functions is to make sure parent pointers are modified correctly.

**Submission Instructions:** Using NetBeans, commit all changes
to your project and do a "push to
upstream" to put the most up-to-date files on the Bitbucket
server. Remember: Do *not* create a pull request --
I will clone your repository (if it exists
and you granted me access) at noon on the due date, and will
assume that is your submission. If you intend to keep working on your
project and submit late, please let me know by email, and I will
ignore your repository until the late submission deadline.