Do some code formatting on QuickSort algorithm.

Author: trekhleb

README.md

@@ -78,7 +78,7 @@ a set of rules that precisely defines a sequence of operations.
 *[Insertion Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/insertion-sort)
 *[Heap Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/heap-sort)
 *[Merge Sort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/merge-sort)
-*[Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort)
+*[Quicksort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/quick-sort) - in-place and non-in-place implementations
 *[Shellsort](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/sorting/shell-sort)
 ***Tree**
 *[Depth-First Search](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/depth-first-search) (DFS)

src/algorithms/sorting/quick-sort/QuickSort.js

@@ -1,6 +1,10 @@
 importSortfrom'../Sort';
 
 exportdefaultclassQuickSortextendsSort{
+/**
+ * @param{*[]} originalArray
+ * @return{*[]}
+ */
 sort(originalArray){
 // Clone original array to prevent it from modification.
 constarray=[...originalArray];

src/algorithms/sorting/quick-sort/QuickSortInPlace.js

@@ -1,35 +1,51 @@
 importSortfrom'../Sort';
 
 exportdefaultclassQuickSortInPlaceextendsSort{
-/* Sorting in place avoids unnecessary use of additional memory, but modifies input array.
+/** Sorting in place avoids unnecessary use of additional memory, but modifies input array.
  *
  * This process is difficult to describe, but much clearer with a visualization:
- * http://www.algomation.com/algorithm/quick-sort-visualization
+ * @see: http://www.algomation.com/algorithm/quick-sort-visualization
+ *
+ * @param{*[]} originalArray
+ * @param{number} inputLowIndex
+ * @param{number} inputHighIndex
+ * @return{*[]}
  */
-sort(originalArray,inputLow,inputHigh){
+sort(originalArray,inputLowIndex,inputHighIndex){
 // Destructures array on initial passthrough, and then sorts in place.
-constarray=inputLow===undefined ? [...originalArray] : originalArray;
-// Partition array segment and return index of last swap
-constpartition=(l,h)=>{
-constswap=(left,right)=>{
-consttempVariable=array[left];
-array[left]=array[right];
-array[right]=tempVariable;
+constarray=inputLowIndex===undefined ? [...originalArray] : originalArray;
+
+/**
+ * Partition array segment and return index of last swap
+ *
+ * @param{number} lowIndex
+ * @param{number} highIndex
+ * @return{number}
+ */
+constpartition=(lowIndex,highIndex)=>{
+/**
+ * @param{number} leftIndex
+ * @param{number} rightIndex
+ */
+constswap=(leftIndex,rightIndex)=>{
+consttempVariable=array[leftIndex];
+array[leftIndex]=array[rightIndex];
+array[rightIndex]=tempVariable;
 };
 
-constpivot=array[h];
+constpivot=array[highIndex];
 this.callbacks.visitingCallback(array[pivot]);
-letfirstRunner=l-1;
 
-for(letsecondRunner=l;secondRunner<h;secondRunner+=1){
+letfirstRunner=lowIndex-1;
+for(letsecondRunner=lowIndex;secondRunner<highIndex;secondRunner+=1){
 if(this.comparator.lessThan(array[secondRunner],pivot)){
 firstRunner+=1;
 swap(firstRunner,secondRunner);
 }
 }
 
 if(this.comparator.lessThan(pivot,array[firstRunner+1])){
-swap(firstRunner+1,h);
+swap(firstRunner+1,highIndex);
 }
 
 returnfirstRunner+1;
@@ -40,20 +56,21 @@ export default class QuickSortInPlace extends Sort{
  * still have to set `high`'s default within the function as we
  * don't have access to `array.length - 1` when declaring paramaters
  */
-constlow=inputLow===undefined ? 0 : inputLow;
-consthigh=inputHigh===undefined ? array.length-1 : inputHigh;
+constlowIndex=inputLowIndex===undefined ? 0 : inputLowIndex;
+consthighIndex=inputHighIndex===undefined ? array.length-1 : inputHighIndex;
 
 // Base case is when low and high converge
-if(low<high){
-constpartitionIndex=partition(low,high);
+if(lowIndex<highIndex){
+constpartitionIndex=partition(lowIndex,highIndex);
 /*
  * `partition()` swaps elements of the array based on their comparison to the `hi` parameter,
  * and then returns the index where swapping is no longer necessary, which can be best thought
  * of as the pivot used to split an array in a non-in-place quicksort
  */
-this.sort(array,low,partitionIndex-1);
-this.sort(array,partitionIndex+1,high);
+this.sort(array,lowIndex,partitionIndex-1);
+this.sort(array,partitionIndex+1,highIndex);
 }
+
 returnarray;
 }
 }