Initial Commit

Author: mattan

sorts/radix_sort.go

@@ -0,0 +1,73 @@
+package sorts
+
+import (
+	"math"
+)
+
+func max(arr []int) int {
+	max := math.MinInt64
+	for _, item := range arr {
+		if item > max {
+			max = item
+		}
+	}
+	return max
+}
+
+func countSort(arr []int, exp int) []int {
+	var digits [10]int
+	var output = make([]int, len(arr))
+	for _, item := range arr {
+		digits[(item/exp)%10]++
+	}
+
+	for i := 1; i < 10; i++ {
+		digits[i] += digits[i-1]
+	}
+
+	for i := len(arr) - 1; i >= 0; i-- {
+		output[digits[(arr[i]/exp)%10]-1] = arr[i]
+		digits[(arr[i]/exp)%10]--
+	}
+
+	return output
+}
+
+func RadixSort(arr []int) []int {
+	maxElement := max(arr)
+	for exp := 1; maxElement/exp > 0; exp *= 10 {
+		arr = countSort(arr, exp)
+	}
+	return arr
+}
+
+// The following adds support for signed ints
+/*
+
+func unsignedRadixSort(arr []int) []int {
+	maxElement := max(arr)
+	for exp := 1; maxElement/exp > 0; exp *= 10 {
+		arr = countSort(arr, exp)
+	}
+	return arr
+}
+
+func RadixSort(arr []int) []int {
+	var negatives, nonNegatives []int
+
+	for _, item := range arr {
+		if item < 0 {
+			negatives = append(negatives, -item)
+		} else {
+			nonNegatives = append(nonNegatives, item)
+		}
+	}
+	negatives = unsignedRadixSort(negatives)
+
+	// Reverse the negative array and restore signs
+	for i, j := 0, len(negatives) -1; i < j; i,j = i + 1, j - 1 {
+		negatives[i], negatives[j] = -negatives[j], -negatives[i]
+	}
+	return append(negatives, unsignedRadixSort(nonNegatives)...)
+}
+*/

sorts/sorts_test.go

@@ -95,6 +95,19 @@ func TestShell(t *testing.T) {
 	}
 }
 
+func TestRadix(t *testing.T) {
+	for _, test := range sortTests {
+		actual := RadixSort(test.input)
+		pos, sorted := compareSlices(actual, test.expected)
+		if !sorted {
+			if pos == -1 {
+				t.Errorf("test %s failed due to slice length changing", test.name)
+			}
+			t.Errorf("test %s failed at index %d", test.name, pos)
+		}
+	}
+}
+
 /*func TestTopological(t *testing.T) {
 	for _, test := range sortTests {
 		actual := topologicalSort(test.input)
@@ -119,13 +132,13 @@ func BenchmarkBubble(b *testing.B) {
 	}
 }
 
-func BenchmarkSelection(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		for _, test := range sortTests {
-			selectionSort(test.input)
-		}
-	}
-}
+//func BenchmarkSelection(b *testing.B) {
+//	for i := 0; i < b.N; i++ {
+//		for _, test := range sortTests {
+//			selectionSort(test.input)
+//		}
+//	}
+//}
 
 func BenchmarkInsertion(b *testing.B) {
 	for i := 0; i < b.N; i++ {
@@ -167,6 +180,14 @@ func BenchmarkShell(b *testing.B) {
 	}
 }
 
+func BenchmarkRadix(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			RadixSort(test.input)
+		}
+	}
+}
+
 /*func BenchmarkTopological(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {