quick sort

Author: rohan-paul

Sorting/quick-sort-Hoare.js

@@ -0,0 +1,72 @@
+	// First write the swap function, which is just a helper function to swap values of the array.
+	function swap(array, i, j) {
+		var temp = array[i];
+		array[i] = array[j];
+		array[j] = temp;
+	}
+
+	function quicksortHoare(array, left, right) {
+		// left-pointer would be the index of the first element which is 0 and right-pointer would be the index of the last element which would be (length -1).
+		left = left || 0;
+		right = right || array.length - 1;
+
+		var pivot = partitionHoare(array, left, right);
+
+		if (left < pivot - 1) {
+			quicksortHoare(array, left, pivot - 1);
+		}
+
+		if (right > pivot) {
+			quicksortHoare(array, pivot, right)
+		}
+
+		return array;
+
+	}
+
+	/* Two indices that start at the ends of the array being partitioned, then move toward each other, until they detect an inversion: a pair of elements, one greater than the pivot, one smaller, that are in the wrong order relative to each other. The inverted elements are then swapped. 
+	Here the numerical values of left and right is continually getting updated with each inner while loop. But only if the while loop condition gets satisfied. That is, when the while loop condition is unsatisfied, e.g. for the first inner while loop, when array[left] > array[pivot] which means we have found a misplaced pair. 
+
+	That is, although the left <= right (which is being made sure by the outer while loop) the actual elements are not sorted. Meaning a left side element is larger in value than the right side element. So, the code execution then jumps out of the inner while loop and goes right in to execute the swap function.
+	*/
+	function partitionHoare(array, left, right) {
+		var pivot = Math.floor((left + right) / 2);
+
+		while (left < right) {
+			while (array[left] < array[pivot]) {
+				left++
+			}
+			while (array[right] > array[pivot]) {
+				right--
+			}
+
+			if (left <= right) {
+				swap(array, left, right);
+				left++
+				right--
+			}
+		}
+		return left;
+	}
+
+
+
+	/******************* Testing Hoare algorithm *********************/
+
+	function getRandomInt(min, max) {
+		return Math.floor(Math.random() * (max - min + 1)) + min;
+		// By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
+	}
+
+	var arr = [];
+
+	for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
+		arr.push(getRandomInt(1, 100));
+	}
+
+	console.log("Unsorted array: ");
+	console.log(arr); //printing unsorted array
+
+	arr = quicksortHoare(arr, 0, arr.length - 1);
+	console.log("Sorted array: ");
+	console.log(arr);

Sorting/quick-sort-Lomuto.js

@@ -0,0 +1,60 @@
+// First write the swap function, which is just a helper function to swap values of the array.
+function swap(array, i, j) {
+	var temp = array[i];
+	array[i] = array[j];
+	array[j] = temp;
+}
+
+function quicksortLomuto(array, left, right) {
+	// left-pointer would be the index of the first element which is 0 and right-pointer would be the index of the last element which would be (length -1).
+	left = left || 0;
+	right = right || array.length - 1;
+
+	var pivot = partitionLomuto(array, left, right);
+
+	if (left < pivot - 1) {
+		quicksortLomuto(array, left, pivot - 1);
+	}
+
+	if (right > pivot) {
+		quicksortLomuto(array, pivot - 1, right)
+	}
+
+	return array;
+}
+
+function partitionLomuto(array, left, right) {
+	// Lomuto algorithm always uses the last element, array[right], for the pivot.
+	var pivot = right;
+	var i = left;
+
+	/*The logic under Lomuto is, we start from the leftmost element and keep track of index of smaller (or equal to) elements as j. While traversing, if we find a smaller element, we swap current element with arr[j]. Otherwise we ignore current element.*/
+	for (var j = left; j < right; j++) {
+		if (array[j] <= array[pivot]) {
+			swap(array, i, j);
+			i++
+		}
+	}
+	swap(array, i, j);
+	return i;
+}
+
+/******************* Testing Lomuto algorithm *********************/
+
+function getRandomInt(min, max) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+	// By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
+}
+
+var arr = [];
+
+for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
+	arr.push(getRandomInt(1, 100));
+}
+
+console.log("Unsorted array: ");
+console.log(arr); //printing unsorted array
+
+arr = quicksortLomuto(arr, 0, arr.length - 1);
+console.log("Sorted array: ");
+console.log(arr);

Sorting/quick-sort-basic.js

@@ -0,0 +1,55 @@
+// sorting the below array with quick sorting
+
+/*The algorithm for Quicksort is:
+1. Pick a pivot element that divides the list into two sublists.
+
+2. Reorder the list so that all elements less than the pivot element are placed before
+the pivot and all elements greater than the pivot are placed after it.
+
+3. Repeat steps 1 and 2 on both the list with smaller elements and the list of larger
+elements.*/
+
+// basic implementation, where pivot is the first element, without usuing swap function and partition function.
+
+function quickSortBasic(array) {
+  if(array.length < 2) {
+    return array;
+  }
+
+  var pivot = array[0];
+  var lesserArray = [];
+  var greaterArray = [];
+
+  for (var i = 1; i < array.length; i++) {
+    if ( array[i] > pivot ) {
+      greaterArray.push(array[i]);
+    } else {
+      lesserArray.push(array[i]);
+    }
+  }
+
+  return quickSortBasic(lesserArray).concat(pivot, quickSortBasic(greaterArray));
+}
+
+
+/******************* Testing Quick sort algorithm *********************/
+
+// Returns a random integer between min (inclusive) and max (inclusive). Using Math.round() will give a non-uniform distribution, which we dont want in this case.
+
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+  // By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
+}
+
+var arr = [];
+
+for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
+  arr.push(getRandomInt(1, 100));
+}
+
+console.log("Unsorted array: ");
+console.log(arr); //printing unsorted array
+
+arr = quickSortBasic(arr, 0, arr.length - 1);
+console.log("Sorted array: ");
+console.log(arr);