Radix Sort code and README file added

Author: me-shaon

README.md

@@ -36,7 +36,7 @@
   - Bucket Sort
   - [Counting Sort](./Sorting/Counting%20Sort/)
   - Heap Sort
-  - Radix Sort
+  - [Radix Sort](./Sorting/Radix%20Sort/)
 
 
 - Graph Algorithms

Sorting/Counting Sort/counting_sort.js

@@ -25,7 +25,7 @@ function countingSort(arr) {
 	return sortedArray;
 }
 
-/******************* Testing Selection sort algorithm *********************/
+/******************* Testing Counting sort algorithm *********************/
 
 /**
  * Returns a random integer between min (inclusive) and max (inclusive)

Sorting/Insertion Sort/insertion-sort.js

@@ -19,7 +19,7 @@ function insertionSort(arr) {
 	return arr;
 }
 
-/******************* Testing Selection sort algorithm *********************/
+/******************* Testing Insertion sort algorithm *********************/
 
 /**
  * Returns a random integer between min (inclusive) and max (inclusive)

Sorting/Radix Sort/README.md

@@ -0,0 +1,74 @@
+# Radix Sort
+
+**Radix sort** is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value. The idea of Radix Sort is to do digit by digit sort starting from least significant digit to most significant digit. Radix sort uses [counting sort](../Counting%20Sort/) as a subroutine to sort.
+
+#### Idea:
+![Radix Sort](./images/radix-sort.png)
+
+Assume the input array is:
+123, 2, 999, 609, 111
+
+Based on the algorithm, we will sort the input array according to the one's digit (least significant digit).
+
+```
+[0]:
+[1]: 111
+[2]: 2
+[3]: 123
+[4]:
+[5]:
+[6]:
+[7]:
+[8]:
+[9]: 999, 609
+```
+
+So, the array becomes 111, 2, 123, 999, 609. Note that we placed 999 before 609 because it appeared first.
+
+Now, we'll sort according to the ten's digit:
+
+```
+[0]: 609, 2
+[1]: 111
+[2]: 123
+[3]:
+[4]:
+[5]:
+[6]:
+[7]:
+[8]:
+[9]: 999
+```
+
+Now, the array becomes : 609, 2, 111, 123, 999
+
+Finally , we sort according to the hundred's digit (most significant digit):
+
+```
+[0]: 2
+[1]: 111, 123
+[2]:
+[3]:
+[4]:
+[5]:
+[6]: 609
+[7]:
+[8]:
+[9]: 999
+```
+
+The array becomes : 2, 111, 123, 609, 999 which is sorted. This is how Radix Sort algorithm works.
+
+
+#### Video Tutorial
+<a href="http://www.youtube.com/watch?feature=player_embedded&v=YXFI4osELGU" target="_blank"><img src="http://img.youtube.com/vi/YXFI4osELGU/0.jpg"
+alt="Counting Sort (youtube)" width="640" height="480" border="10" /></a>
+
+
+#### Complexity Analysis
+The time complexity for radix sort is : O(d(n+b)), where b is the base for representing numbers, for example, for decimal system, b is 10. If k is the maximum possible value, then d would be O(log<sub>b</sub>(k)). So overall time complexity is O((n+b) * logb(k))
+
+### More on this topic
+- [Radix Sort - WikiPedia](https://en.wikipedia.org/wiki/Radix_sort)
+- [Radix Sort - HackerEarth Tutorial](https://www.hackerearth.com/practice/algorithms/sorting/radix-sort/tutorial/)
+- [Radix Sort - geeksforgeeks](http://www.geeksforgeeks.org/radix-sort/)

Sorting/Radix Sort/images/radix-sort.png

@@ -0,0 +1,78 @@
+/* Radix Sort implementation in JavaScript */
+
+function radixSort(arr) {
+	var maxDigit = getMaxDigitLen(arr);
+
+	//Looping for every digit index from leftmost digits to rightmost digits
+	for (var i = 1; i <= maxDigit; i++) {
+
+		// rebuild the digit buckets according to this digit
+		var digitBuckets = [];
+		for (var j = 0; j < arr.length; j++) {
+			var digit = getDigit(arr[j], i); //get the i-th digit of the j-th element of the array
+
+			digitBuckets[digit] = digitBuckets[digit] || []; //If empty initialize with empty array
+			digitBuckets[digit].push(arr[j]); //Add the number in it's respective digits bucket
+		}
+
+		// rebuild the array according to this digit
+		var index = 0;
+		for (var k = 0; k < digitBuckets.length; k++) {
+			if (digitBuckets[k] && digitBuckets[k].length > 0) {
+				for (j = 0; j < digitBuckets[k].length; j++) {
+					arr[index++] = digitBuckets[k][j];
+				}
+			}
+		}
+	}
+	return arr;
+}
+
+// helper function to get the last n-th(position) digit of a number
+var getDigit = function(num, position) {
+	var num_length = num.toString().length;
+
+	if (num_length < position)
+		return 0;
+
+	var radixPosition = Math.pow(10, position - 1); //number with the positions-th power of 10
+
+	/*
+    Logic: To find the 2nd digit of the number 123
+	       we can divide it by 10, which is 12
+	       and the using the modulus operator(%) we can find 12 % 10 = 2
+    */
+	var digit = (Math.floor(num / radixPosition)) % 10;
+
+	return digit;
+};
+
+// helper function get the length of digits of the max value in this array
+var getMaxDigitLen = function(arr) {
+	var maxVal = Math.max.apply(Math, arr); //Finding max value from the array
+
+	return Math.ceil(Math.log10(maxVal));
+};
+
+/******************* Testing Radix sort algorithm *********************/
+
+/**
+ * Returns a random integer between min (inclusive) and max (inclusive)
+ * Using Math.round() will give you a non-uniform distribution!
+ */
+function getRandomInt(min, max) {
+	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));
+}
+
+console.log("Unsorted array: ");
+console.log(arr); //printing unsorted array
+
+arr = radixSort(arr);
+console.log("Sorted array: ");
+console.log(arr); //printing sorted array