WebSVN – programming – Diff – /cs241/p5/Test.java

 // Written by Ira Snyder
+// Project #5
+// Due Date: 12-03-2004
+// People Helped: Allen Oliver
 import java.io.*;
 import java.util.Random;
 public class Test {
+    //some variables to keep track of compares and swaps
     private static int compCount, swapCount;
+    //the class Entry, which stores int's
     private class Entry implements Comparable {
-        public int x;
+        public int x; //the data
+        //constructor
         public Entry( int x ) { this.x = x; }
+        //method to compare this to another object
+        //returns 0 if they are equal, >0 if this is bigger,
+        //and <0 if o is bigger
         public int compareTo( Object o ) {
             compCount++;
             if( !(o instanceof Entry) ) throw new IllegalArgumentException();
             Entry y = (Entry)o;
             return this.x - y.x;
+        }
+        //change the value of the current Entry
         public Entry setEntry( int x ) {
             return new Entry(x);
+        }
+        //print the Entry
         public String toString() { return Integer.toString(x); }
     } //end Entry class
+    //get the private variables
     public int getCompCount() { return compCount; }
     public int getSwapCount() { return swapCount; }
+    //reset compares and swaps
     public void resetCompCount() { compCount = 0; }
     public void resetSwapCount() { swapCount = 0; }
     //this is the only way a swap method can be made in java.
     //the usual C++ (and others) way of using pointers is not
     //possible in java. (I've come up with a very solid
     //explanation of this. See me if you want to know.)
+    //
+    //this method adds to swapcount, and should be called for swaps
+    //during a test run
     public static void swap( Object[] array, int posA, int posB ) {
         Object temp = array[posB];  // temp = B
-        array[posB] = array[posA]; // B = A
+        array[posB] = array[posA];  // B = A
-        array[posA] = temp;        // A = temp
+        array[posA] = temp;         // A = temp
         swapCount++;
+    }
+    //method to print the entire array of type Object
     public void printArray( Object[] array, PrintStream ps ) {
         int i=0;
         for( i=0; i<array.length-1; i++ ) { System.out.print(array[i] + ", "); }
         System.out.println(array[i]); //print the last element
+    }
+    //method to generate an array of Entry's. It can generate arrays of
+    //any size, and will generate then with different ordering of numbers
+    //inside the array
+    //
     // howMany should be how many numbers you want to generate
     // order: 0 = random
     //        1 = ascending
     //        2 = descending
     public Entry[] generateNumbers( int howMany, int order ) {
         Random generator = new Random();
         Entry[] answer = new Entry[howMany];
+        //if order is a bad value, throw an Exception
         if( order < 0 || order > 3 ) throw new IllegalArgumentException();
         for( int i=0; i<howMany; i++ ) {
             //I deemed random int's from 0 to 10239 to be a good test
+            //so I used these instead of the default, which is from
+            // -MAX_INT to +MAX_INT
             if( order == 0 ) { answer[i] = new Entry(generator.nextInt(10240)); }
             else if( order == 1) { answer[i] = new Entry(i); } //ascending
             else if( order == 2 ){ answer[i] = new Entry(howMany-i-1); } //descending
             else { answer[i] = new Entry(1); } //set all to 1.0
+        }
         return answer;
+    }
+    //method to generate a nice header for the program's output
+    //I did this to eliminate duplicate code
     private String generateHeader() {
         StringBuffer output = new StringBuffer("Method");
         StringBuffer spaces = new StringBuffer();
         for( int i=output.length(); i<20; i++ ) { spaces.append(" "); }
         output.append("Number Swaps");
         return output.toString();
+    }
+    //method to generate a properly spaced output line, which is used
+    //to output the type of sort method, the number of swaps, and the
+    //number of compares
+    //
+    //this prints out the number of swaps and compares that are stored
+    //at the time that this is called
     private String generateOutputLine( String name ) {
         StringBuffer output = new StringBuffer(name); //put the name
         StringBuffer spaces = new StringBuffer();
         for( int i=output.length(); i<20; i++ ) { spaces.append(" "); }
         output.append(getSwapCount()); //appends the current number of swaps
         return output.toString();
+    }
+    //method to run BubbleSort and print the output
     public void testBubbleSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //resets the counting variables
         resetCompCount();
-        SortMethods.BubbleSort(array);
+        SortMethods.BubbleSort(array); //sort the array
+        //print the output line
         System.out.println( generateOutputLine("BubbleSort"));
+    }
+    //method to run ImprovedBubbleSort and print the output
     public void testImprovedBubbleSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //resets the counting variables
         resetCompCount();
-        SortMethods.ImprovedBubbleSort(array);
+        SortMethods.ImprovedBubbleSort(array); //sort the array
+        //print the output line
         System.out.println( generateOutputLine("Impr. BubbleSort"));
+    }
+    //method to run SelectionSort and print the output
     public void testSelectionSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.SelectionSort(array);
+        SortMethods.SelectionSort(array); //sort the array
+        //print the output line
         System.out.println( generateOutputLine("SelectionSort"));
+    }
+    //method to run InsertionSort and print the output
     public void testInsertionSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.InsertionSort(array);
+        SortMethods.InsertionSort(array); //sort the array
+        //print the output line
         System.out.println( generateOutputLine("InsertionSort"));
+    }
+    //method to run ShellSort and print the output line
     public void testShellSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.ShellSort(array);
+        SortMethods.ShellSort(array); //sort the array
+        //print the output line
         System.out.println( generateOutputLine("ShellSort"));
+    }
+    //method to run the MergeSort and print the output line
     public void testMergeSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.MergeSort(array);
+        SortMethods.MergeSort(array); //sort the array
+        //print the output line for MergeSort
         System.out.println( generateOutputLine("MergeSort"));
+    }
+    //method to run the HeapSort and print the output line
     public void testHeapSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.HeapSort(array);
+        SortMethods.HeapSort(array); //sort the array
+        //print the output line for HeapSort
         System.out.println( generateOutputLine("HeapSort"));
+    }
+    //method to run QuickSort on the array, and print the output line
     public void testQuickSort( Entry[] array ) {
-        resetSwapCount();
+        resetSwapCount(); //reset counting variables
         resetCompCount();
-        SortMethods.QuickSort(array);
+        SortMethods.QuickSort(array); //sort the array
+        //print the output line for QuickSort
         System.out.println( generateOutputLine("QuickSort"));
+    }
+    //a generic method that will print out the header given to it
+    // as a parameter, then run the suite of tests on the given array
     public void runTest( Entry[] array, String testHeader ) {
-        //make 6 arrays
+        //make 6 arrays (copies)
         Entry[] arrayc1 = new Entry[array.length];
         Entry[] arrayc2 = new Entry[array.length];
         Entry[] arrayc3 = new Entry[array.length];
         Entry[] arrayc4 = new Entry[array.length];
         Entry[] arrayc5 = new Entry[array.length];
         System.arraycopy(array,0,arrayc4,0,array.length);
         System.arraycopy(array,0,arrayc5,0,array.length);
         System.arraycopy(array,0,arrayc6,0,array.length);
         System.arraycopy(array,0,arrayc7,0,array.length);
+        //print both headers
         System.out.println(testHeader);
         System.out.println( generateHeader() );
+        //run each test on one copy of the original array
-        testBubbleSort(array);
+        testBubbleSort(array);              //BubbleSort
-        testImprovedBubbleSort(arrayc1);
+        testImprovedBubbleSort(arrayc1);    //ImprovedBubbleSort
-        testSelectionSort(arrayc2);
+        testSelectionSort(arrayc2);         //SelectionSort
-        testInsertionSort(arrayc3);
+        testInsertionSort(arrayc3);         //InsertionSort
-        testShellSort(arrayc4);
+        testShellSort(arrayc4);             //ShellSort (AKA Comb Sort)
-        testMergeSort(arrayc5);
+        testMergeSort(arrayc5);             //MergeSort
-        testHeapSort(arrayc6);
+        testHeapSort(arrayc6);              //HeapSort
-        testQuickSort(arrayc7);
+        testQuickSort(arrayc7);             //QuickSort
+    }
+    //run the test for 512 random elements
     public void test1() {
         Entry[] array = generateNumbers(512,0);
         String header = "Test 1: Array Length 512 Composed of Random Elements";
         runTest(array,header);
+    }
+    //run the test for 1024 random elements
     public void test2() {
         Entry[] array = generateNumbers(1024,0);
         String header = "Test 2: Array Length 1024 Composed of Random Elements";
         runTest(array,header);
+    }
+    //run the test for 2048 random elements
     public void test3() {
         Entry[] array = generateNumbers(2048,0);
         String header = "Test 3: Array Length 2048 Composed of Random Elements";
         runTest(array,header);
+    }
+    //run the test for 4096 random elements
     public void test4() {
         Entry[] array = generateNumbers(4096,0);
         String header = "Test 4: Array Length 4096 Composed of Random Elements";
         runTest(array,header);
+    }
+    //run the test for 1024 Ascending elements (0,1,2 ... 1023,1024)
     public void test5() {
         Entry[] array = generateNumbers(1024,1);
         String header = "Test 5: Array Length 1024 Composed of Ascending Elements";
         runTest(array,header);
+    }
+    //run the test for 1024 Descending elements (1024,1023 ... 2,1,0)
     public void test6() {
         Entry[] array = generateNumbers(1024,2);
         String header = "Test 6: Array Length 1024 Composed of Descending Elements";
         runTest(array,header);
+    }
+    //run the test for 1024 elements that all have the value 1.0
     public void test7() {
         Entry[] array = generateNumbers(1024,3);
         String header = "Test 7: Array Length 1024 Composed of Elements of value 1.0";
         runTest(array,header);
+    }

Subversion Repositories programming

(root)/cs241/p5/Test.java @ 56 – Rev 55 → 56