Sorting algorithms

Author: Deepak Malik

README.md

@@ -16,7 +16,7 @@ Implementation of Algorithms in Java, Most of these names are picked up from Gee
 	- [X] [Merge Sort](../master/src/com/deepak/algorithms/Sorting/MergeSort.java)
 	- [X] [Counting Sort](../master/src/com/deepak/algorithms/Sorting/CountingSort.java)
 	- [ ] Shell Sort
-	- [ ] Quick Sort
+	- [X] [Quick Sort](../master/src/com/deepak/algorithms/Sorting/QuickSort.java)
 	- [ ] Heap Sort
 	- [ ] Radix Sort
 

src/com/deepak/algorithms/Bit_Manipulation/UsefulOperations.java

@@ -126,7 +126,7 @@ public static int countSetBits(int a) {
 	 * @param b - Second Number
 	 * @return {@link Map<String, Integer>} - Result
 	 */
-	public Map<String, Integer> swap2Integers(int a, int b) {
+	public static Map<String, Integer> swap2Integers(int a, int b) {
 		Map<String, Integer> result = new HashMap<>();
 		a ^= b;
 		b ^= a;

src/com/deepak/algorithms/Sorting/BubbleSort.java

@@ -7,7 +7,8 @@
 import com.deepak.algorithms.Library.ArrayUtils;
 
 /**
- * Class for BubbleSort implementation
+ * BubbleSort Implementation
+ * 
  * @author Deepak
  */
 public class BubbleSort {
@@ -36,17 +37,20 @@ public class BubbleSort {
 	 * Average - O(n^2)
 	 * Worst - O(n^2)
 	 * 
-	 * @param listOfValues - List of values passed in the request
+	 * @param list - List of values passed in the request
 	 */
-	public static Integer[] performBubbleSort(Integer[] listOfValues) {
-		for (int i = 0; i < listOfValues.length; i++) {
-			for (int j = 1; j < (listOfValues.length - i); j++) {
-				if (listOfValues[j - 1] > listOfValues[j]) {
-					ArrayUtils.swap(listOfValues, j - 1, j);
+	public static Integer[] performBubbleSort(Integer[] list) {
+		/* Loop through the entire collection */
+		for (int i = 0; i < list.length; i++) {
+			/* Loop through rest of the elements */
+			for (int j = 1; j < (list.length - i); j++) {
+				/* If previous is greater then the current, swap it */
+				if (list[j - 1] > list[j]) {
+					ArrayUtils.swap(list, j - 1, j);
 				}
 			}
 		}
-		return listOfValues;
+		return list;
 	}
 
 }

src/com/deepak/algorithms/Sorting/CountingSort.java

@@ -1,11 +1,12 @@
 /**
- * Algorithms-in-Java
+ * Algorithms-In-Java
  * CountingSort.java
  */
 package com.deepak.algorithms.Sorting;
 
 /**
- * Class for CountingSort implementation
+ * Counting Sort Implementation
+ * 
  * @author Deepak
  */
 public class CountingSort {
@@ -24,55 +25,42 @@ public static void main(String[] args) {
 	 * Counting sort is a sorting technique based on keys between a specific range.
 	 * It works by counting the number of objects having distinct key values (kind of hashing).
 	 * Then doing some arithmetic to calculate the position of each object in the output sequence.
+	 * 
 	 * <p>Notes:
-	 * 	1. Counting sort is efficient if the range of input data is not significantly greater than the number of objects to be sorted.
-	 * 		Consider the situation where the input sequence is between range 1 to 10K and the data is 10, 5, 10K, 5K.
-	 	2. It is not a comparison based sorting. It running time complexity is O(n) with space proportional to the range of data.
-	 	3. It is often used as a sub-routine to another sorting algorithm like radix sort.
-	 	4. Counting sort uses a partial hashing to count the occurrence of the data object in O(1).
-	 	5. Counting sort can be extended to work for negative inputs also.
-	 	6. This type of integer sorting algorithms are usually designed to work in either the pointer machine or random access machine models of computing
-	 	</p>
+	 * 1. Counting sort is efficient if the range of input data is not significantly greater than the number of objects to be sorted.
+	 * 		- Consider the situation where the input sequence is between range 1 to 10K and the data is 10, 5, 10K, 5K.
+	 * 2. It is not a comparison based sorting. It running time complexity is O(n) with space proportional to the range of data.
+	 * 3. It is often used as a sub-routine to another sorting algorithm like radix sort.
+	 * 4. Counting sort uses a partial hashing to count the occurrence of the data object in O(1).
+	 * 5. Counting sort can be extended to work for negative inputs also.
+	 * 6. This type of integer sorting algorithms are usually designed to work in either the pointer machine or random access machine models of computing
+	 * </p>
 	 */
-    private static void performCountingSort(int[] values) {
-
-
-			int n = values.length;
-
-			// The output character array that will have sorted arr
-			int output[] = new int[n];
-
-			// Create a count array to store count of inidividul
-			// characters and initialize count array as 0
-			int count[] = new int[256];
-			for (int i=0; i<256; ++i)
-				count[i] = 0;
-
-			// store count of each character
-			for (int i=0; i<n; ++i)
-				++count[values[i]];
-
-			// Change count[i] so that count[i] now contains actual
-			// position of this character in output array
-			for (int i=1; i<=255; ++i)
-				count[i] += count[i-1];
-
-			// Build the output character array
-			for (int i = 0; i<n; ++i)
-			{
-				output[count[values[i]]-1] = values[i];
-				--count[values[i]];
-			}
-
-			// Copy the output array to arr, so that arr now
-			// contains sorted characters
-			for (int i = 0; i<n; ++i)
-				values[i] = output[i];
-
-		System.out.print("Sorted  array is ");
-		for (int i=0; i<values.length; ++i)
-			System.out.print(values[i]+",");
+	private static void performCountingSort(int[] values) {
+		/* Find the length of the collection */
+		int n = values.length;
+		/* Output character array which will hold the sorted array */
+		int output[] = new int[n];
+		/* Create a count array of 256 size, and store the count of each character in it */
+		int count[] = new int[256];
+		for (int i = 0; i < n; ++i) {
+			++count[values[i]];
+		}
+		/* Change count[i] so that count[i] now contains actual position of the character */
+		for (int i = 1; i <= 255; ++i) {
+			count[i] += count[i-1];
+		}
+		/* Build the output character array */	
 
+		// Build the output character array
+		for (int i = 0; i<n; ++i) {
+			output[count[values[i]] - 1] = values[i];
+			--count[values[i]];
+		}
+		System.out.print("Sorted  array is : ");
+		for (int i = 0; i < output.length; ++i) {
+			System.out.print(output[i]+", ");
+		}
 	}
 
 }

src/com/deepak/algorithms/Sorting/InsertionSort.java

@@ -7,14 +7,15 @@
 import com.deepak.algorithms.Library.ArrayUtils;
 
 /**
- * Insertion sort implementation
+ * Insertion Sort Implementation
  * 
  * @author Deepak
  */
 public class InsertionSort {
 
 	/**
 	 * Insertion Sort implementation
+	 * 
 	 * <p> Question - When will you consider a list of items to be sorted?
 	 * Answer - When all the elements to the left of each element are smaller then the element
 	 * 
@@ -37,17 +38,21 @@ public class InsertionSort {
 	 * Average - O(n^2)
 	 * Worst - O(n^2)
 	 * 
-	 * @param listOfValues - List of values passed in the request
+	 * @param list - List of values passed in the request
 	 */
-	public static Integer[] performInsertionSort(Integer[] listOfValues) {
-		for (int i = 1; i < listOfValues.length; i++) {
+	public static Integer[] performInsertionSort(Integer[] list) {
+		/* Loop through the items starting from 1. 
+		 * 1st element is always considered as sorted */
+		for (int i = 1; i < list.length; i++) {
+			/* Loop through the rest of the elements and compare each with the previous one.
+			 * If small, swap it */
 			for (int j = i; j > 0; j--) {
-				if (listOfValues[j] < listOfValues[j - 1]) {
-					ArrayUtils.swap(listOfValues, j, j - 1);
+				if (list[j] < list[j - 1]) {
+					ArrayUtils.swap(list, j, j - 1);
 				}
 			}
 		}
-		return listOfValues;
+		return list;
 	}
 
 }

src/com/deepak/algorithms/Sorting/MergeSort.java

@@ -1,19 +1,21 @@
 /**
- * Algorithms-in-Java
+ * Algorithms-In-Java
  * MergeSort.java
  */
 package com.deepak.algorithms.Sorting;
 
 import java.util.Arrays;
 
 /**
- * Class for MergeSort implementation
+ * MergeSort Implementation
+ * 
  * @author Deepak
  */
 public class MergeSort {
 
 	/**
 	 * Main method to start the flow of program
+	 * 
 	 * @param args
 	 */
 	public static void main(String[] args) {
@@ -32,52 +34,61 @@ public static void main(String[] args) {
 	 * Average - O(n log(n))
 	 * Worst - O(n log(n))
 	 * 
-	 * @param listOfValues - List of values passed in the request
+	 * @param list - List of values to be sorted
+	 * @param low - lowest index i.e 0
+	 * @param high - highest index i.e list.length - 1
 	 */
-	public static int[] performMergeSort(int[] iListOfValues, int iLowestPosition, int iHighestPosition) {
-		if (iLowestPosition < iHighestPosition) {
-			int middlePosition = iLowestPosition + (iHighestPosition - iLowestPosition) / 2;
-			performMergeSort(iListOfValues, iLowestPosition, middlePosition);
-			performMergeSort(iListOfValues, middlePosition + 1, iHighestPosition);
-			merge(iListOfValues, iLowestPosition, middlePosition, iHighestPosition);
+	public static int[] performMergeSort(int[] list, int low, int high) {
+		/* If low is less then high, find the middle position,
+		 * and perform merge sort on both the sides of the list.
+		 * Finally, merge the two sorted parts */
+		if (low < high) {
+			int middle = low + (high - low) / 2;
+			/* Merge sort of left side */
+			performMergeSort(list, low, middle);
+			/* Merge sort on right side */
+			performMergeSort(list, middle + 1, high);
+			merge(list, low, middle, high);
 		}
-		return iListOfValues;
+		return list;
 	}
 
 	/**
-	 * Method to merge two items from the list
-	 * @param iListOfValues
-	 * @param iLowestPosition
-	 * @param middlePosition
-	 * @param iHighestPosition
-	 * @return {@link int[]} 
+	 * Method to merge a list 
+	 * 
+	 * @param list
+	 * @param low
+	 * @param middle
+	 * @param high
+	 * @return {@link int[]}
 	 */
-	private static int[] merge(int[] iListOfValues, int iLowestPosition, int middlePosition, int iHighestPosition) {
-		int[] copyOfArrays = new int[iListOfValues.length];
-		for (int i = 0; i < iListOfValues.length; i++ ) {
-			copyOfArrays[i] = iListOfValues[i];
+	private static int[] merge(int[] list, int low, int middle, int high) {
+		/* Create a new copy of array and fill it with same elements */
+		int[] copy = new int[list.length];
+		for (int i = 0; i < list.length; i++ ) {
+			copy[i] = list[i];
 		}
-
-		int i = iLowestPosition;
-		int j = middlePosition + 1;
-		int k = iLowestPosition;
-
-		while (i <= middlePosition && j <= iHighestPosition) {
-			if (copyOfArrays[i] <= copyOfArrays[j]) {
-				iListOfValues[k] = copyOfArrays[i];
+		/* Find i, j and k */
+		int i = low;
+		int j = middle + 1;
+		int k = low;
+		/* TODO : Explain what is happening here */
+		while (i <= middle && j <= high) {
+			if (copy[i] <= copy[j]) {
+				list[k] = copy[i];
 				i++;
 			} else {
-				iListOfValues[k] = copyOfArrays[j];
+				list[k] = copy[j];
 				j++;
 			}
 			k++;
 		}
-		while (i <= middlePosition) {
-			iListOfValues[k] = copyOfArrays[i];
+		while (i <= middle) {
+			list[k] = copy[i];
 			k++;
 			i++;
 		}
-		return iListOfValues;
+		return list;
 	}
 
 }