CS 112 Project 9: Binary Search Trees
Objectives:
 Practice building BST operations.
 Practice building recursive operations.
 Learn more about binary search trees.
Introduction
This week's project is a single person project.
The project is to:
 Add a new method to your BST class:
 bst.getHeight() should return the height of the tree in bst.
For example, if bst is empty, it should return 0;
if bst contains a single item, it should return 1;
if it contains 2 items, it should return 2;
if it is balanced and contains 3 items, it should return 2,
otherwise, it should return 3;
if it is balanced and contains 4 items, it should return 3,
otherwise, it should return 4; etc.
 Convert your BST into a template; and
 Use your BST<Item> to conduct an experiment.
As usual, you should use testdrive development to accomplish these tasks.
The Experiment
The height of a BST determines the speed of operations like insert() and contains().
If we build a "large" BST of N items (e.g., ~2^{20}), and that tree is balanced, then its height
should be the minimal O(lg(N)) (e.g., 20).
This week's problem is to conduct a simple experiment to see how "tall" BSTs get, given random values.
Our objective is to see how close we come to lg(N) height if we build large trees of N
randomly ordered values.
In the ulab, the folder:
/home/cs/112/proj/09
contains ten data files
(randomInts01.txt, randomInts02.txt, ..., randomInts10.txt),
each containing 2^{20}1 = 1,048,575 randomly generated integer values.
If these values were ordered in exactly the right way, we could build trees of height 20.
(On the other hand, if they were ordered in exactly the wrong way, we could build trees of height 1,048,575!)
Your task is to write a simple program that prompts the user for the name of an input file,
reads each value from that file, and inserts it into a BST.
Your program should then display the height of the resulting BST.
There are three minor details to keep in mind:

There may be duplicate values within an input file,
and inserting a duplicate value into our BST will throw an exception.
Your program should count and output the number of duplicate values
in a given file by catching and handling this exception.

Each of these input files is about 20 MB in size.
To avoid killing your diskspace quota, your program should open
and read the files directly from that folder.
(Hint: use a file's full filename to open it:
e.g., /home/cs/112/proj/09/randomInts01.txt.)

These files were generated in the ulab (whose workstations are 64bit machines),
and so the integers in these files are 64bit integers.
However, the C++ int and unsigned types only store integers in
32 bits; the long type stores integers in 64 bits,
so use it to store these 64bit integers.
Since there are ten input files,
you will need to run your program ten times.
(Or find a clever way to automate this.)
For each file, record the corresponding treeheight in a spreadsheet,
and the number of duplicate values that were found.
Given all ten heights, use the spreadsheet to calculate the minimum height,
the maximum height, the average height, the median height, and the
standard deviation of the ten heights.
(Your spreadsheet will make each of these computations easy.)
Finally, use your spreadsheet to create a barchart
showing each of the ten heights,
as a visualization of your data.
Save this chart in the worksheet where you recorded and analyzed your data.
Finally
Answer the following questions in your spreadsheet, below the chart:
 Is lg(N) or N a better approximation
for your measured heights? Why?
 How much variance is there in the height of these trees?
Is this surprising? Why or why not?
 How many duplicate values were there (on average)?
Is this surprising? Why or why not?
 The "big Oh" notation O(f(n)) implies
that there are constants a and b,
such that a * f(n) + b describes the reality
for which O(f(n)) is an approximation.
A balanced BST of N items has height O(lg(N)).
Theoretically, there should be values
a and b such that a * lg(N) + b
describes the actual height of a BST built using random data.
Using your experimental results, what is a reasonable value
for a?
Submit

A hard copy of this grade sheet,
attached to:
 a hard copy of a
script file that lists the files in your project,
shows that it compiles/links correctly, and shows it correctly
running and providing the required functionality.

as many hard copies as necessary to show your spreadsheet's data and each of its charts.

An electronic copy of your project (including your spreadsheet), in your
/home/cs/112/current/yourUserName/proj9 folder.
CS >
112 >
Projects >
09
This page maintained by
Joel Adams.