Adding a Radix LSB

Author: alpgcosta

algorithm/category.json

@@ -30,7 +30,8 @@
       "bubble": "Bubble Sort",
       "quick": "Quicksort",
       "merge": "Mergesort",
-      "heap" : "Heap Sort"
+      "heap" : "Heap Sort",
+      "radixlsb" : "Radix LSB sort"
     }
   },
   "string": {

algorithm/category.json~

@@ -0,0 +1,49 @@
+{
+  "graph_search": {
+    "name": "Graph Search",
+    "list": {
+      "dfs": "DFS",
+      "bfs": "BFS",
+      "dijkstra": "Dijkstra",
+      "bellman_ford": "Bellman-Ford",
+      "floyd_warshall": "Floyd-Warshall",
+      "topological_sort": "Topological-Sort"
+    }
+  },
+  "mst": {
+    "name": "Minimum Spanning Tree",
+    "list": {
+      "prim": "Prim's Algorithm"
+    }
+  },
+  "search": {
+    "name": "Search",
+    "list": {
+      "binary_search": "Binary Search"
+    }
+  },
+  "sorting": {
+    "name": "Sorting",
+    "list": {
+      "insertion": "Insertion Sort",
+      "selection": "Selection Sort",
+      "bubble": "Bubble Sort",
+      "quick": "Quicksort",
+      "merge": "Mergesort",
+      "heap" : "Heap Sort"
+    }
+  },
+  "string": {
+   		"name": "String",
+   		"list": {
+   			"edit_distance": "Edit Distance"
+   		}
+   },
+  "etc": {
+    "name": "Uncategorized",
+    "list": {
+      "dp": "Dynamic Programming",
+      "scratch_paper": "<i class='fa fa-code'></i> Scratch Paper"
+    }
+  }
+}

algorithm/sorting/radixlsb/basic/code.js

@@ -0,0 +1,40 @@
+tracer._print('original array = [' + D[0].join(', ') + ']');
+tracer._sleep(1000);
+tracer._pace(300);
+function pow(base, expo){
+	var ans = 1;
+	for(var i = 0; i < expo;i++){
+		ans *= base;
+	}
+	return ans;
+}
+for(var exp = 0; exp < 8;exp ++){
+	tracer._print("Bit "+exp);
+	for(var i = 0; i < D[0].length; i++){
+		tracer._select(0, i);
+		D[2][ parseInt( D[0][i] / pow(2, exp)  % 2) ] += 1;
+		tracer._notify(2, parseInt( D[0][i] / pow(2, exp)  % 2) );
+		tracer._deselect(0, i);
+	}
+	D[2][1] += D[2][0];
+	tracer._notify(2, 1);
+	for(var i = D[0].length - 1; i >= 0; i--){
+		tracer._select(0, i);
+		D[2][parseInt( D[0][i] / pow(2, exp)  % 2) ] -= 1;
+		tracer._notify(2, parseInt( D[0][i] / pow(2, exp)  % 2) );
+		D[1][ D[2][ parseInt( D[0][i] / pow(2, exp)  % 2) ] ] = D[0][i];
+		tracer._notify(1, D[2][ parseInt( D[0][i] / pow(2, exp)  % 2) ] );
+		tracer._deselect(0, i);
+	}
+	for(var i = 0; i < D[0].length; i++){
+		tracer._select(1, i);
+		D[0][i] = D[1][i];
+		tracer._notify(0, i);
+		tracer._deselect(1, i);
+	}
+	D[2][0] = 0;
+	D[2][1] = 0;
+	tracer._notify(2, 0);
+	tracer._notify(2, 1);	
+}
+tracer._print('sorted array = [' + D[0].join(', ') + ']');

algorithm/sorting/radixlsb/basic/data.js

@@ -0,0 +1,8 @@
+var tracer = new Array2DTracer();
+var k = [5,4,3,5,7,5,6,9];
+var D = [
+	k,
+	Array1D.random(k.length),
+	[0,0]
+];
+tracer._setData(D);

algorithm/sorting/radixlsb/desc.json

@@ -0,0 +1,13 @@
+{
+  "Radix LSB Sort": "Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual bits which share the same significant position and value.",
+  "Complexity": {
+    "time": "worst O(n), best O(n), average O(n)",
+    "space": "always O(n)"
+  },
+  "References": [
+    "<a href='https://en.wikipedia.org/wiki/Radix_sort'>Wikipedia</a>"
+  ],
+  "files": {
+    "basic": "Basic"
+  }
+}