Now, radix LSD, plus selction changed in a bit of visualz

Author: alpgcosta

algorithm/category.json

@@ -31,7 +31,7 @@
       "quick": "Quicksort",
       "merge": "Mergesort",
       "heap" : "Heap Sort",
-      "radixlsb" : "Radix LSB sort"
+      "radixlsd" : "Radix LSD sort"
     }
   },
   "string": {

algorithm/category.json~

@@ -0,0 +1,44 @@
+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 < 6;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(10, exp)  % 10) ] += 1;
+		tracer._notify(2, parseInt( D[0][i] / pow(10, exp)  % 10) );
+		tracer._deselect(0, i);
+	}
+	for(var i = 1; i < 10; i++){
+		tracer._select(2, i - 1);
+		D[2][i] += D[2][i - 1];
+		tracer._notify(2, i);
+		tracer._deselect(2, i - 1);
+	}
+	for(var i = D[0].length - 1; i >= 0; i--){
+		tracer._select(0, i);
+		D[2][parseInt( D[0][i] / pow(10, exp)  % 10) ] -= 1;
+		tracer._notify(2, parseInt( D[0][i] / pow(10, exp)  % 10) );
+		D[1][ D[2][ parseInt( D[0][i] / pow(10, exp)  % 10) ] ] = D[0][i];
+		tracer._notify(1, D[2][ parseInt( D[0][i] / pow(10, exp)  % 10) ] );
+		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);
+	}
+	for(var i = 0; i < 10; i++){
+		D[2][i] = 0;
+		tracer._notify(2, i);
+	}	
+}
+tracer._print('sorted array = [' + D[0].join(', ') + ']');

algorithm/sorting/radixlsb/basic/code.js

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

algorithm/sorting/radixlsd/basic/code.js

@@ -1,5 +1,5 @@
 {
-  "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.",
+  "Radix LSD 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.",
   "Complexity": {
     "time": "worst O(n), best O(n), average O(n)",
     "space": "always O(n)"