Adding comb sort

Author: kavithajm

sort/combSort.go

@@ -0,0 +1,30 @@
+// Implementation of comb sort algorithm, an improvement of bubble sort
+// Reference: https://www.geeksforgeeks.org/comb-sort/
+
+package sort
+
+func getNextGap(gap int) int {
+	gap = (gap * 10) / 13
+	if gap < 1 {
+		return 1
+	}
+	return gap
+}
+
+func combSort(data []int) []int {
+	n := len(data)
+	gap := n
+	swapped := true
+
+	for gap != 1 || swapped {
+		gap = getNextGap(gap)
+		swapped = false
+		for i := 0; i < n-gap; i++ {
+			if data[i] > data[i+gap] {
+				data[i], data[i+gap] = data[i+gap], data[i]
+				swapped = true
+			}
+		}
+	}
+	return data
+}

sort/countingsort.go

@@ -0,0 +1,25 @@
+// countingsort.go
+// description: Implementation of counting sort algorithm
+// details: A simple counting sort algorithm implementation
+// author [Phil](https://github.com/pschik)
+// see sort_test.go for a test implementation, test function TestQuickSort
+
+// package sort provides primitives for sorting slices and user-defined collections
+package sort
+
+func Count(data []int) []int {
+	var aMin, aMax = -1000, 1000
+	count := make([]int, aMax-aMin+1)
+	for _, x := range data {
+		count[x-aMin]++
+	}
+	z := 0
+	for i, c := range count {
+		for c > 0 {
+			data[z] = i + aMin
+			z++
+			c--
+		}
+	}
+	return data
+}

sort/sorts_test.go

@@ -23,28 +23,24 @@ func testFramework(t *testing.T, sortingFunction func([]int) []int) {
 			expected: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 			name:     "Reversed Unsigned",
 		},
-
 		//Sorted slice
 		{
 			input:    []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 			name:     "Sorted Signed",
 		},
-
 		//Reversed slice
 		{
 			input:    []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
 			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 			name:     "Reversed Signed",
 		},
-
 		//Reversed slice, even length
 		{
 			input:    []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
 			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 			name:     "Reversed Signed #2",
 		},
-
 		//Random order with repetitions
 		{
 			input:    []int{-5, 7, 4, -2, 6, 5, 8, 3, 2, -7, -1, 0, -3, 9, -6, -4, 10, 9, 1, -8, -9, -10},
@@ -98,8 +94,73 @@ func TestHeap(t *testing.T) {
 	testFramework(t, HeapSort)
 }
 
+func TestCount(t *testing.T) {
+	testFramework(t, Count)
+}
+
 func TestQuick(t *testing.T) {
-	testFramework(t, QuickSort)
+	testCases := []struct {
+		input    []int
+		expected []int
+		name     string
+	}{
+		//Sorted slice
+		{
+			input:    []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			expected: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			name:     "Sorted Unsigned",
+		},
+		//Reversed slice
+		{
+			input:    []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1},
+			expected: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			name:     "Reversed Unsigned",
+		},
+		//Sorted slice
+		{
+			input:    []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			name:     "Sorted Signed",
+		},
+		//Reversed slice
+		{
+			input:    []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
+			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			name:     "Reversed Signed",
+		},
+		//Reversed slice, even length
+		{
+			input:    []int{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10},
+			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+			name:     "Reversed Signed #2",
+		},
+		//Random order with repetitions
+		{
+			input:    []int{-5, 7, 4, -2, 6, 5, 8, 3, 2, -7, -1, 0, -3, 9, -6, -4, 10, 9, 1, -8, -9, -10},
+			expected: []int{-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10},
+			name:     "Random order Signed",
+		},
+		//Single-entry slice
+		{
+			input:    []int{1},
+			expected: []int{1},
+			name:     "Singleton",
+		},
+		{
+			input:    []int{},
+			expected: []int{},
+			name:     "Empty Slice",
+		},
+	}
+	for _, test := range testCases {
+		t.Run(test.name, func(t *testing.T) {
+			QuickSort(test.input)
+			if !reflect.DeepEqual(test.input, test.expected) {
+				t.Errorf("test %s failed", test.name)
+				t.Errorf("actual %v expected %v", test.input, test.expected)
+			}
+		})
+	}
 }
 
 func TestShell(t *testing.T) {
@@ -122,6 +183,10 @@ func TestSelection(t *testing.T) {
 	testFramework(t, SelectionSort)
 }
 
+func TestComb(t *testing.T) {
+	testFramework(t, combSort)
+}
+
 //END TESTS
 
 func benchmarkFramework(b *testing.B, f func(arr []int) []int) {
@@ -136,23 +201,18 @@ func benchmarkFramework(b *testing.B, f func(arr []int) []int) {
 		//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 Unsigned"},
-
 		//Sorted slice
 		{[]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 Signed"},
-
 		//Reversed slice
 		{[]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 Signed"},
-
 		//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 Signed #2"},
-
 		//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 Signed"},
-
 		//Empty slice
 		{[]int{}, []int{}, "Empty"},
 		//Single-entry slice
@@ -188,8 +248,45 @@ func BenchmarkHeap(b *testing.B) {
 	benchmarkFramework(b, HeapSort)
 }
 
+func BenchmarkCount(b *testing.B) {
+	benchmarkFramework(b, Count)
+}
+
 func BenchmarkQuick(b *testing.B) {
-	benchmarkFramework(b, QuickSort)
+	var sortTests = []struct {
+		input    []int
+		expected []int
+		name     string
+	}{
+		//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 Unsigned"},
+		//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 Unsigned"},
+		//Sorted slice
+		{[]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 Signed"},
+		//Reversed slice
+		{[]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 Signed"},
+		//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 Signed #2"},
+		//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 Signed"},
+		//Empty slice
+		{[]int{}, []int{}, "Empty"},
+		//Single-entry slice
+		{[]int{1}, []int{1}, "Singleton"},
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			QuickSort(test.input)
+		}
+	}
 }
 
 func BenchmarkShell(b *testing.B) {
@@ -213,4 +310,8 @@ func BenchmarkSelection(b *testing.B) {
 	benchmarkFramework(b, SelectionSort)
 }
 
+func BenchmarkComb(b *testing.B) {
+	benchmarkFramework(b, combSort)
+}
+
 //END BENCHMARKS