- Added new test cases for sort, with negative integers

- Changed sort function names to uppercase where they were lowercase
- Enclosed each iteration in t.Run() to ensure all tests are executed
- Added a unified test framework to avoid code duplication
- Fixed Radix sort to deal with negative numbers

Author: mattan

sorts/heap_sort.go

@@ -33,7 +33,7 @@ func (h maxHeap) MaxHeapify(i int) {
 
 func (h maxHeap) size() int { return h.heapSize } // ???
 
-func heapSort(slice []int) []int {
+func HeapSort(slice []int) []int {
 	h := buildMaxHeap(slice)
 	//log.Println(slice)
 	for i := len(h.slice) - 1; i >= 1; i-- {

sorts/insertion_sort.go

@@ -1,7 +1,7 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-func insertionSort(arr []int) []int {
+func InsertionSort(arr []int) []int {
 	for out := 1; out < len(arr); out++ {
 		temp := arr[out]
 		in := out

sorts/quick_sort.go

@@ -5,7 +5,7 @@ import (
 	"math/rand"
 )
 
-func quickSort(arr []int) []int {
+func QuickSort(arr []int) []int {
 
 	if len(arr) <= 1 {
 		return arr
@@ -28,8 +28,8 @@ func quickSort(arr []int) []int {
 		}
 	}
 
-	lowPart = quickSort(lowPart)
-	highPart = quickSort(highPart)
+	lowPart = QuickSort(lowPart)
+	highPart = QuickSort(highPart)
 
 	lowPart = append(lowPart, middlePart...)
 	lowPart = append(lowPart, highPart...)

sorts/radix_sort.go

@@ -1,11 +1,7 @@
 package sorts
 
-import (
-	"math"
-)
-
 func max(arr []int) int {
-	max := math.MinInt64
+	max := arr[0]
 	for _, item := range arr {
 		if item > max {
 			max = item
@@ -17,10 +13,10 @@ func max(arr []int) int {
 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]
 	}
@@ -33,18 +29,10 @@ func countSort(arr []int, exp int) []int {
 	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 {
+	if len(arr) == 0 {
+		return arr
+	}
 	maxElement := max(arr)
 	for exp := 1; maxElement/exp > 0; exp *= 10 {
 		arr = countSort(arr, exp)
@@ -65,9 +53,8 @@ func RadixSort(arr []int) []int {
 	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 {
+	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/shell_sort.go

@@ -1,7 +1,7 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-func shellSort(arr []int) []int {
+func ShellSort(arr []int) []int {
 	for d := int(len(arr) / 2); d > 0; d /= 2 {
 		for i := d; i < len(arr); i++ {
 			for j := i; j >= d && arr[j-d] > arr[j]; j -= d {

sorts/sorts_case_test.go

@@ -13,25 +13,39 @@ type sortTest struct {
 	name     string
 }
 
+var uarr []int = makeRandNonNegativeArray(500_000)
 var arr []int = makeRandArray(500_000)
 
 var sortTests = []sortTest{
 	//Sorted slice
-	{[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-		[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "Sorted"},
+	{[]int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+		[]int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "Sorted"},
+
 	//Reversed slice
-	{[]int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1},
-		[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "Reversed"},
+	{[]int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
+		[]int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "Reversed"},
+
+	//Reversed slice, even length
+	{[]int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
+		[]int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "Reversed Even"},
+
+	//Random order with repetitions
+	{[]int{-5, 7, 4, -2, 6, 5, 8, 3, 2, -7, -1, 0, -3, 9, -6, -4, 10, 9, 1, -8, -9, -10},
+		[]int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10}, "Random order with repetitions"},
+
 	//Empty slice
 	{[]int{}, []int{}, "Empty"},
 	//Single-entry slice
 	{[]int{1}, []int{1}, "Singleton"},
 
-	//500k values sort
-	{arr, getSortedVersion(arr), "Large Random"},
+	//500k non negative int values sort
+	{uarr, getSortedVersion(uarr), "Large Random"},
+
+	//500k int values sort
+	{arr, getSortedVersion(arr), "Large Random2"},
 }
 
-func makeRandArray(size int) []int {
+func makeRandNonNegativeArray(size int) []int {
 	vals := make([]int, size)
 	for i := 0; i < size; i++ {
 		temp, _ := rand.Int(rand.Reader, big.NewInt(int64(size)))
@@ -40,6 +54,15 @@ func makeRandArray(size int) []int {
 	return vals
 }
 
+func makeRandArray(size int) []int {
+	vals := make([]int, size)
+	for i := 0; i < size; i++ {
+		temp, _ := rand.Int(rand.Reader, big.NewInt(int64(size)))
+		vals[i] = int(temp.Int64()) - 250_000
+	}
+	return vals
+}
+
 func getSortedVersion(a []int) []int {
 	sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })
 	return a

sorts/sorts_test.go

@@ -1,125 +1,63 @@
 package sorts
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
-//BEGIN TESTS
-
-func TestBubble(t *testing.T) {
+func testFramework(t *testing.T, sortingFunction func([]int) []int) {
 	for _, test := range sortTests {
-		actual := bubbleSort(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.Run(test.name, func(t *testing.T) {
+			actual := sortingFunction(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)
+				}
+
+				for i := pos - 10; i < pos+10; i++ {
+					fmt.Print(actual[i], " ")
+				}
+				t.Errorf("test %s failed at index %d", test.name, pos)
+
 			}
-			t.Errorf("test %s failed at index %d", test.name, pos)
-		}
+		})
 	}
 }
 
-func TestSelection(t *testing.T) {
-	for _, test := range sortTests {
-		actual := selectionSort(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)
-		}
-	}
+//BEGIN TESTS
+
+func TestBubble(t *testing.T) {
+	testFramework(t, bubbleSort)
 }
 
 func TestInsertion(t *testing.T) {
-	for _, test := range sortTests {
-		actual := insertionSort(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)
-		}
-	}
+	testFramework(t, InsertionSort)
 }
 
 func TestMerge(t *testing.T) {
-	for _, test := range sortTests {
-		actual := Mergesort(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)
-		}
-	}
+	testFramework(t, Mergesort)
 }
 
 func TestHeap(t *testing.T) {
-	for _, test := range sortTests {
-		actual := heapSort(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)
-		}
-	}
+	testFramework(t, HeapSort)
 }
 
 func TestQuick(t *testing.T) {
-	for _, test := range sortTests {
-		actual := quickSort(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)
-		}
-	}
+	testFramework(t, QuickSort)
 }
 
 func TestShell(t *testing.T) {
-	for _, test := range sortTests {
-		actual := shellSort(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)
-		}
-	}
+	testFramework(t, ShellSort)
 }
 
 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)
-		}
-	}
+	testFramework(t, RadixSort)
 }
 
-/*func TestTopological(t *testing.T) {
-	for _, test := range sortTests {
-		actual := topologicalSort(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) {
+	testFramework(t, topologicalSort)
+} */
 
 //END TESTS
 
@@ -143,7 +81,7 @@ func BenchmarkSelection(b *testing.B) {
 func BenchmarkInsertion(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {
-			insertionSort(test.input)
+			InsertionSort(test.input)
 		}
 	}
 }
@@ -159,23 +97,23 @@ func BenchmarkMerge(b *testing.B) {
 func BenchmarkHeap(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {
-			heapSort(test.input)
+			HeapSort(test.input)
 		}
 	}
 }
 
 func BenchmarkQuick(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {
-			quickSort(test.input)
+			QuickSort(test.input)
 		}
 	}
 }
 
 func BenchmarkShell(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {
-			shellSort(test.input)
+			ShellSort(test.input)
 		}
 	}
 }