Quick sort README file added and Code comment updated

Author: me-shaon

Sorting/Merge Sort/README.md

@@ -12,6 +12,7 @@ While comparing two sub-lists for merging, the first element of both lists is ta
 ![Merge Sort](./images/merge-sort.png)
 
 #### A visualization on Merge Sort
+
 ![Merge sort demonstration](./images/merge-sort-animation.gif)
 
 *An example of merge sort. First divide the list into the smallest unit (1 element), then compare each element with the adjacent list to sort and merge the two adjacent lists. Finally all the elements are sorted and merged. (image source-wikipedia)*

Sorting/Quick Sort/README.md

@@ -0,0 +1,36 @@
+# Quick Sort
+
+**Quick sort** is based on the divide-and-conquer approach based on the idea of choosing one element as a pivot element and partitioning the array around it such that: Left side of pivot contains all the elements that are less than the pivot element Right side contains all elements greater than the pivot
+
+It reduces the space complexity and removes the use of the auxiliary array that is used in merge sort. Selecting a random pivot in an array results in an improved time complexity in most of the cases.
+
+Like Merge Sort, Quick Sort is a Divide and Conquer algorithm. It picks an element as pivot and partitions the given array around the picked pivot. There are many different versions of Quick Sort that pick pivot in different ways.
+
+- Always pick first element as pivot.
+- Always pick last element as pivot (implemented below)
+- Pick a random element as pivot.
+- Pick median as pivot.
+
+The principle of the quicksort algorithm is this:
+
+- Pick a “pivot” element.
+- “Partition” the array into 3 parts:
+    - First part: all elements in this part is less than the pivot.
+    - Second part: the pivot itself (only one element!)
+    - Third part: all elements in this part is greater than or equal to the pivot.
+- Then, apply the quicksort algorithm to the first and the third part. (recursively)
+
+![Quick Sort](./images/quick-sort.gif)
+
+#### Complexity Analysis
+- Worst Case - O(n<sup>2</sup>)
+- Average Case - O(nlogn)
+- Best Case - O(nlogn)
+
+### More on this topic
+- [Quick Sort - Wikipedia](https://en.wikipedia.org/wiki/Quicksort)
+- [Quick Sort - KhanAcademy Tutorial](https://www.khanacademy.org/computing/computer-science/algorithms/quick-sort/a/overview-of-quicksort)
+- [Understanding Quicksort (with interactive demo)](http://me.dt.in.th/page/Quicksort/)
+- [Quick Sort - HackerEarch Tutorial](https://www.hackerearth.com/practice/algorithms/sorting/quick-sort/tutorial/)
+- [Sorting - TopCoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/sorting/)
+- [Computer science in JavaScript: Quicksort](https://www.nczonline.net/blog/2012/11/27/computer-science-in-javascript-quicksort/)

Sorting/Quick Sort/images/quick-sort.gif

@@ -1,47 +1,51 @@
-// Merge Sort Implementation
-function quickSort(arr, left, right){
-    var index;
+/* Quick Sort Implementation in JavaScript */
 
-    if(arr.length > 1){
-        index = partition(arr, left, right);
+function quickSort(arr, left, right) {
+	var index;
 
-        if(left < index - 1){
-            quickSort(arr, left, index - 1);
-        }
+	//Partition the  array and recursively sort them
+	if (arr.length > 1) {
+		index = partition(arr, left, right);
 
-        if(index < right){
-            quickSort(arr, index, right);
-        }
-    }
+		if (left < index - 1) {
+			quickSort(arr, left, index - 1);
+		}
 
-    return arr;
+		if (index < right) {
+			quickSort(arr, index, right);
+		}
+	}
+
+	return arr;
 }
 
-function partition(arr, left, right){
+function partition(arr, left, right) {
 
-    var pivot = arr[Math.floor((right+left)/2)];
-    var i = left, j = right;
+	var pivot = arr[Math.floor((right + left) / 2)]; //Taking the middle element of the list as Pivot
+	var i = left,
+		j = right;
 
-    while(i <= j){
-        while(arr[i] < pivot){
-            i++;
-        }
+	while (i <= j) {
+		while (arr[i] < pivot) {
+			i++;
+		}
 
-        while(arr[j] > pivot){
-            j--;
-        }
+		while (arr[j] > pivot) {
+			j--;
+		}
 
-        if(i <= j){
-            var tmp = arr[i];
-            arr[i] = arr[j];
-            arr[j] = tmp;
+		//If the elements from the left and right are swappable (means right one is smaller than the pivot and left one is larger than the pivot) then swap them
+		if (i <= j) {
+			var tmp = arr[i];
+			arr[i] = arr[j];
+			arr[j] = tmp;
 
-            i++;
-            j--;
-        }
-    }
+			i++;
+			j--;
+		}
+	}
 
-    return i;
+	return i;
 }
 
 /******************* Testing Quick sort algorithm *********************/
@@ -51,13 +55,13 @@ function partition(arr, left, right){
  * Using Math.round() will give you a non-uniform distribution!
  */
 function getRandomInt(min, max) {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
+	return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
 var arr = [];
 
-for(var i=0;i<10;i++){ //initialize a random integer unsorted array
-    arr.push(getRandomInt(1, 100));
+for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
+	arr.push(getRandomInt(1, 100));
 }
 
 console.log("Unsorted array: ");