Added comments and removed some non-DRY code

Author: dlarocque

src/com/example/algorithmvisualizer/AlgVisualizer.java

@@ -15,14 +15,12 @@
 
 import java.util.*;
 import javax.swing.*;
-import javax.swing.event.ChangeEvent;
-import javax.swing.event.ChangeListener;
-
 import java.awt.event.*;
+import javax.swing.event.*;
 
 public class AlgVisualizer implements ActionListener, ChangeListener {
 
-	private final int FPS_MIN = 2;
+	private final int FPS_MIN = 2;  
 	private final int FPS_INIT = 10;
 	private final int FPS_MAX = 100;
 	private String[] sizeOptions = { "10", "50", "100", "300", "450", "900" }; // array size options
@@ -31,24 +29,28 @@ public class AlgVisualizer implements ActionListener, ChangeListener {
 	private int delay;
 	private long totalDelay;
 	private Integer indexComparisons;
-	private long startTime; // start time of a sort
+	private long startTime;             // start time of a sort
 	private long visualizationTime;
 	private long sortingTime;
 	private boolean doBubbleSort;
 	private boolean doInsertionSort;
 	private boolean doSelectionSort;
 	private boolean doMergeSort;
 	private boolean doQuickSort;
-	private boolean stopSort; // True if sorting is stopped
-	private Integer[] arr; // array that is going to be sorted
+	private boolean stopSort;          // True if sorting is stopped
+	private Integer[] arr;             // array that is going to be sorted
 	private ContentWindow frame;
 	private SwingWorker<Void, Integer[]> arrSort;
 
 
 	/*
-	 * When an action is performed on a component on the JFrame that has had this
+	 * actionPerformed(ActionEvent event)
+     *
+     * When an action is performed on a component on the JFrame that has had this
 	 * classes actionListener added to it, this method will decide what to do based
-	 * on what component was clicked on. When a sorting button is clicked, its
+	 * on the event.
+     * 
+     * When a sorting button is clicked, its
 	 * respective boolean do(..)Sort will be set to true, and arrSort().execute.
 	 * This will call the doInBackground() method in the arrSort object, where it
 	 * will use the do(..)Sort variable to discover which sorting algorithm to use,
@@ -62,7 +64,9 @@ public void actionPerformed(ActionEvent event) {
 		doInsertionSort = false;
 		doMergeSort = false;
 		doQuickSort = false;
+
 		// Find the source of the action
+        // Is there a better way to do this?
 		if (event.getSource() == frame.getBubbleButton()) {
 			doBubbleSort = true;
 			arrSort.execute();
@@ -91,6 +95,15 @@ public void actionPerformed(ActionEvent event) {
 		}
 	}
 
+    /*
+     * stateChanged(ChangeEvent e)
+     *
+     * This method is called when the FPS slider
+     * is shifted to change the FPS of sorting.
+     *
+     * We change the amount of delay occuring in the 
+     * sorting to what the value of the slider was moved to.
+     */
 	@Override
 	public void stateChanged(ChangeEvent e) {
 		JSlider source = (JSlider) e.getSource();
@@ -99,10 +112,13 @@ public void stateChanged(ChangeEvent e) {
 			setDelay(delay);
 	}
 
-	/*
+	/* 
+     * reset()
+     *
 	 * Reset method is called whenever the user presses the reset button, or when a
-	 * new size of array is chosen from the size changer. This method stops sorting,
-	 * re-shuffles the array, clears all swapped indexes, frames painted, tracked
+	 * new size of array is chosen from the size changer. 
+     *
+     * This method stops sorting, re-shuffles the array, clears all swapped indexes, frames painted, tracked
 	 * time, and comparisons. It must also reset the swingWorker so that the user is
 	 * able to see another sort. Since sort.execute() can only be called once for
 	 * SwingWorker, we simply re-instantiate it so that we are able to call it
@@ -149,28 +165,38 @@ public Integer[] fillArr(Integer[] arr) {
 	}
 
 	/*
-	 * updatePerformance will be called every time the array is repainted. This
-	 * makes it slower / not real time when there is a high delay.
+	 * updatePerformance()
+     *
+     * This method will be called every time that the frame is updated in order to 
+     * update our performance statistics.
 	 * 
-	 * We get the values for each performance statistic we want to track (number of
-	 * swaps, number of comparisons, visualization time, sorting time), format them
+	 * Finds the values for each performance statistic being tracked (number of
+	 * swaps, number of comparisons, visualization time, sorting time), formats them
 	 * into a string that will then be assigned to the JLabel's text.
 	 * 
 	 * frame.pack() makes sure that our new text will fit in the frame, and will
 	 * adjust if it does not.
 	 */
 	public void updatePerformance() {
 		numSwaps = frame.getArrDisplay().getSwappedIndexes().size();
-		if (!getSort().equals("Not Sorting") && frame.getArrDisplay().getNumChunks() == 0) {
-			visualizationTime = System.currentTimeMillis() - startTime;
-			sortingTime = visualizationTime - totalDelay;
-		} else if (frame.getArrDisplay().getNumChunks() > 1 && !frame.getArrDisplay().isComplete()) {
-			visualizationTime = System.currentTimeMillis() - startTime;
-			sortingTime = visualizationTime - totalDelay;
-		}
+    
+        // updates the sorting times based on whether or not we are currently visualizing a sort
+        if (!getSort().equals("Not Sorting") && frame.getArrDisplay().getNumChunks() == 0) {
+			
+            visualizationTime = System.currentTimeMillis() - startTime;	
+            sortingTime = visualizationTime - totalDelay;
+		
+        } else if (frame.getArrDisplay().getNumChunks() > 1 && !frame.getArrDisplay().isComplete()) { 
+            
+            visualizationTime = System.currentTimeMillis() - startTime;
+			sortingTime = visualizationTime - totalDelay; // visualizationTime < totalDelay makes negative time
+		
+        }
+
 		if (stopSort) {
 			resetTime();
 		}
+
 		String performance = String.format(
 				"Index Comparisons : %d  Index Swaps : %d  Visualization Time : %dms  Sorting Time : %dms",
 				indexComparisons, numSwaps, visualizationTime, sortingTime);

src/com/example/algorithmvisualizer/ArrSorting.java

@@ -96,8 +96,9 @@ protected void process(List<Integer[]> chunks) {
 	private void sleep() {
 		try {
 			Thread.sleep(algVisualizer.getDelay());
-			if (!algVisualizer.stopSort())
-				algVisualizer.setTotalDelay(algVisualizer.getTotalDelay() + algVisualizer.getDelay());
+			if (!algVisualizer.stopSort()) {
+                algVisualizer.setTotalDelay(algVisualizer.getTotalDelay() + algVisualizer.getDelay());
+            }
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
@@ -222,66 +223,80 @@ private void mergeSort(int l, int r) {
 		}
 	}
 
-	// Merges two subarrays of arr[].
-	// First subarray is arr[l..m]
-	// Second subarray is arr[m+1..r]
 	private void merge(int l, int m, int r) {
 		if (algVisualizer.getSort().equals("Merge Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
-			// Find sizes of two subarrays to be merged
-			int n1 = m - l + 1;
+			
+            int n1 = m - l + 1;
 			int n2 = r - m;
-			// Create temp arrays
-			int L[] = new int[n1];
+			
+            int L[] = new int[n1];
 			int R[] = new int[n2];
-			// Copy data to temp arrays
-			for (int i = 0; i < n1; ++i)
+			
+            for (int i = 0; i < n1; ++i) {
 				L[i] = arr[l + i];
-			for (int j = 0; j < n2; ++j)
+            }
+			for (int j = 0; j < n2; ++j) {
 				R[j] = arr[m + 1 + j];
-			// Merge the temp arrays
-			// Initial indexes of first and second subarrays
+            }
+			
 			int i = 0, j = 0;
-			// Initial index of merged subarray array
 			int k = l;
 			while (i < n1 && j < n2) {
-				if (algVisualizer.stopSort())
+				
+                if (algVisualizer.stopSort()) { // necessary to check this within every loop?
 					break;
+                }
+
 				algVisualizer.setIndexComparisons(algVisualizer.getIndexComparisons() + 1);
-				if (L[i] <= R[j]) {
+				
+                if (L[i] <= R[j]) {
 					arr[k] = L[i];
 					i++;
-					arrDisplay.addSwappedIndexes(k, k + i);
+				
+                    arrDisplay.addSwappedIndexes(k, k + i);
 					publish(arr.clone());
 					sleep();
-				} else {
+				
+                } else {
 					arr[k] = R[j];
 					j++;
-					arrDisplay.addSwappedIndexes(k, k + j);
+				
+                    arrDisplay.addSwappedIndexes(k, k + j);
 					publish(arr.clone());
 					sleep();
-				}
+                }
 				k++;
 			}
-			/* Copy remaining elements of L[] if any */
-			while (i < n1) {
-				if (algVisualizer.stopSort())
+			
+            while (i < n1) {
+				
+                if (algVisualizer.stopSort()) {
 					break;
+                }
+
 				arr[k] = L[i];
-				arrDisplay.addSwappedIndexes(k, k + i);
+				
+                arrDisplay.addSwappedIndexes(k, k + i);
 				publish(arr.clone());
 				sleep();
-				i++;
+				
+                i++;
 				k++;
 			}
-			/* Copy remaining elements of R[] if any */
-			while (j < n2) {
-				if (algVisualizer.stopSort())
+			
+            while (j < n2) {
+				
+                if (algVisualizer.stopSort()) {
 					break;
+                }
+
 				arr[k] = R[j];
-				arrDisplay.addSwappedIndexes(k, k + j);
+				
+                arrDisplay.addSwappedIndexes(k, k + j);
 				publish(arr.clone());
 				sleep();
-				j++;
+				
+                j++;
 				k++;
 			}
 		}
@@ -290,42 +305,45 @@ private void merge(int l, int m, int r) {
 	private void quickSort(int low, int high) {
 		if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
 			if (low < high) {
-				// pi is partitioning index, arr[pi] is now at right place
-				int pi = partition(low, high);
+				
+                int pi = partition(low, high);
 
-				// Recursively sort elements before
-				// partition and after partition
 				quickSort(low, pi - 1);
 				quickSort(pi + 1, high);
 			}
 			if (isSorted() && !algVisualizer.stopSort()) {
-				arrDisplay.setComplete(true);
-				publish(arr.clone());
+                arrDisplay.setComplete(true);
+                publish(arr.clone());
 				sleep();
 			}
 		}
 	}
-
+    
+    // quicksort
 	private int partition(int low, int high) {
 		if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
-			int pivot = arr[high];
-			int i = (low - 1); // index of smaller element
-			for (int j = low; j < high; j++) {
-				if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) {
+			
+            int pivot = arr[high];
+			int i = (low - 1);
+			
+            for (int j = low; j < high; j++) {
+			
+                if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) {
 					algVisualizer.setIndexComparisons(algVisualizer.getIndexComparisons() + 1);
-					// If current element is smaller than the pivot
-					if (arr[j] < pivot) {
+				
+                    if (arr[j] < pivot) {
 						i++;
-						// swap arr[i] and arr[j]
 						int temp = arr[i];
 						arr[i] = arr[j];
 						arr[j] = temp;
-						arrDisplay.addSwappedIndexes(i, j);
+						
+                        arrDisplay.addSwappedIndexes(i, j);
 						publish(arr.clone());
 						sleep();
 					}
 				}
 			}
+
 			if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) {
 				// swap arr[i+1] and arr[high] (or pivot)
 				int temp = arr[i + 1];
@@ -346,9 +364,11 @@ private int partition(int low, int high) {
 	 */
 	private boolean isSorted() {
 		boolean isSorted = true;
-		for (int i = 0; i < arr.length - 1; i++) {
-			if (arr[i] > arr[i + 1])
+		
+        for (int i = 0; i < arr.length - 1; i++) {
+			if (arr[i] > arr[i + 1]) {
 				isSorted = false;
+            }
 		}
 		return isSorted;
 	}