Sorting Project

In this project you will conduct an experimental or empirical study of algorithms. Experimental results play a major role in assessing the worth of many things in computing, but they are rarely done in an undergraduate course of study. In some ways the class Analysis of Algorithms is the most distant course from an experimental approach since it is primarily concerned with a theoretical framework for comparing and assessing algorithms. However, on the same token it is an appropriate place to include some experimental work because it provides a counterpoint to most of the content of the course and it allows us to see how well the theoretical framework predicts reality.

In this project in particular, you will study the efficiency of various sorting algorithms under specific conditions.

Just as in natural science and in engineering, good experiments in computer science must be controlled and reproducible. To allow another person to verify your experiments, you must report such things as the statistics of the machine or machines on which you ran the experiments (processor, speed, memory including cache, operating system), your methodologies (for example, are you taking the average over several runs? how many runs? where did the test cases come from?), and your code.

To make your experiments controlled, particularly in cases when you are concerned with running time, you want to make sure you restrict what you are timing. The Java method for reading from the system clock is System.currentTimeMillis() which gives the time in milliseconds since midnight, Jan 1, 1970. Readings can be made by calling this method before and after the section you wish to time and computing the difference.

However, you want to make sure that you are not including the running of other programs in that timing. At any time, other programs---some even by other users also logged in---could be sharing the processor with your program. If that is the case, the processor cycles spent on those programs affect your running times.

For this reason, rigorous experiments must be done in single user mode or recovery mode of the operating system, where the operating system itself is running at a minimum and where no other user programs may be running. There will be a machine in the lab dedicated for your use in this project. You will be given root access to this machine.

Your first step in this project is to decide on a question to investigate, around which you will build your experiment. Some suggestions follow (but I will consider proposals for questions not on this list):

• Which sort performs better experimentally, Radix sort or Quicksort? In particular, try the version of Radix sort that scales everything to doubles in the range [0,1] and sorts on bits. Can you identify properties of arrays (range, permutedness) where one outperforms the other?
• Quicksort, Mergesort, and Heapsort are all n lg n sorts (at least in the expected case) and all use some sort of recursion. Which is really best in practice? Can you identify properties of arrays (range, permutedness) that affect which sort performs best?
• Which sub-sort gives the best performance for Bucketsort? Do any properties of arrays make a difference?
• Which variation on Quicksort performs best: the standard (in our book), an alternate way to pick the pivot, or the Hoare partition?
• How do the worst sorts compare with each other? Pit Bubblesort, Selectionsort, Insertionsort, and Stoogesort against each other.
• Research and implement the Flashsort algorithm. How does it perform against the best sorts we've seen (say, Quick, Merge, Heap, and/or Radix).
• How good are the sort methods that Java provides? (According to the Java API, Java's standard sort methods use a version of Mergesort).
• For any sort algorithms, is there a difference in running time between array versions and list versions?

You will need to code up the sorts you want to test as well as coding a program that will automate the tests. For your convenience, I am providing a class with some utility methods for generating a random array or list, or reading one from a file. You can get this class from /homes/tvandrun/Public/cs445/SortUtil.java. The linked-list-based methods in SortUtil assume a Node class which you can find at /homes/tvandrun/Public/cs445/Node.java. Feel free to modify these to suit your needs.

Your tasks:

1. Choose a question you are interested in pursuing and make a proposal to me of what you plan to do, including the nature of your experiments and methodologies. I will help you refine this proposal. You may make this proposal either in person or by email.
2. Code up the sorting algorithms and the testing framework. Make sure your algorithms are correct (they sort correctly).
3. Run your experiments.
4. Analyze your data. Make a graphical display of the data which will help you reason about the performance. For example, does the data fit an n lg n curve? If you have a strong background in statistics or data analysis, make use of this skill.
5. Write a report. Shoot for about two pages of text. Describe your methodologies and data analysis, and come to a conclusion. Include your code and professional-looking graphical display.

Due dates: Proposal-- Monday, Sept 29; finished report-- Friday, Oct 17.