Merge Sort comment updated and README added

Author: me-shaon

Sorting/Merge Sort/README.md

@@ -0,0 +1,28 @@
+# Merge Sort
+
+**Merge sort** is a divide-and-conquer algorithm based on the idea of breaking down a list into several sub-lists until each sublist consists of a single element and merging those sublists in a manner that results into a sorted list.
+
+#### Idea:
+- Divide the unsorted list into **N** sublists, each containing **1** element.
+- Take adjacent pairs of two singleton lists and merge them to form a list of 2 elements. **N** will now convert into **N/2** lists of size 2.
+- Repeat the process till a single sorted list of obtained.
+
+While comparing two sub-lists for merging, the first element of both lists is taken into consideration. While sorting in ascending order, the element that is of a lesser value becomes a new element of the sorted list. This procedure is repeated until both the smaller sub-lists are empty and the new combined sub-list comprises all the elements of both the sub-lists.
+
+![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)*
+
+#### Complexity Analysis
+- Worst Case - O(nlogn)
+- Average Case - O(nlogn)
+- Best Case - O(nlogn)
+
+### More on this topic
+- [Merge Sort - Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
+- [Merge Sort - KhanAcademy Tutorial](https://www.khanacademy.org/computing/computer-science/algorithms/merge-sort/a/overview-of-merge-sort)
+- [Merge Sort - HackerEarch Tutorial](https://www.hackerearth.com/practice/algorithms/sorting/merge-sort/tutorial/)
+- [Sorting - TopCoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/sorting/)

Sorting/Merge Sort/images/merge-sort-animation.gif

@@ -1,36 +1,46 @@
-// Merge Sort Implementation
-function mergeSort(arr){
-    var len = arr.length;
+/*  Merge Sort Implementation in JavaScript */
 
-    if(len === 1) return arr;
+function mergeSort(arr) {
+	var len = arr.length;
 
-    var mid = Math.floor(len/2);
-    var left = arr.slice(0, mid);
-    var right = arr.slice(mid, len);
+	if (len === 1) return arr; //Single element left, No need to further divide
 
-    return merge(mergeSort(left), mergeSort(right));
+	var mid = Math.floor(len / 2);
+	var left = arr.slice(0, mid); //grab the left half of the current list
+	var right = arr.slice(mid, len); //grab the right half of the current list
+
+	return merge(mergeSort(left), mergeSort(right)); //recursively call with the list to divide and then merge them two together to get the sorted result
 }
 
-function merge(left, right){
-    var result = [];
-    var leftCount = 0, rightCount = 0;
+//merge the given two portions of a list
+function merge(left, right) {
+	var result = [];
+	var leftCount = 0,
+		rightCount = 0;
+
+	//Compare taking two elements from two list each time and set the smallest one to the new list. continue doing the same until one list is empty
+	while (leftCount < left.length && rightCount < right.length) {
+		if (left[leftCount] < right[rightCount])
+			result.push(left[leftCount++]);
+		else
+			result.push(right[rightCount++]);
+	}
 
-    while(leftCount < left.length && rightCount < right.length){
-        if(left[leftCount] < right[rightCount])
-            result.push(left[leftCount++]);
-        else
-            result.push(right[rightCount++]);
-    }
+	/*If a single list is empty the previous loop will be ended. But we also need to get the leftover from the another list. Following two will just grab the leftovers(if any) from the given two lists.*/
 
-    while(leftCount < left.length){
-        result.push(left[leftCount++]);
-    }
+	//take the leftovers from the left array(if any)
+	//Following loop can also replaced by a single line code like: result.concat(left.slice(leftCount, left.length))
+	while (leftCount < left.length) {
+		result.push(left[leftCount++]);
+	}
 
-    while(rightCount < right.length){
-        result.push(right[rightCount++]);
-    }
+	//take the leftovers from the right array(if any)
+	//Following loop can also replaced by a single line code like: result.concat(right.slice(rightCount, right.length))
+	while (rightCount < right.length) {
+		result.push(right[rightCount++]);
+	}
 
-    return result;
+	return result;
 }
 
 
@@ -41,13 +51,13 @@ function merge(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: ");