Pull request regarding benchmarks and tests (#102)

* Updated packages, removed main from all but topological sort

* Commented out main for the time being

* Removed main from remaining files

* Fixed naming issue

* Renamed heap_sort, top_sort, deleted copy of select, insert

* Added sorts_test and test cases

* Updated linter to check sorts

* Updated selection sort to return []int for testing

* Changed large test to 500k for timeout purposes

* Bubblesort returns a slice for testing purposes

* Added return type to shell sort

* Added tests and benchmarks for each sort

* Commented out top sort temporarily

* Removed prints from heap

* Removed ineffectual assignments in selection sort

* Commenting out top sort as a bandaid fix

Author: c4llmeco4ch

sorts/bubble_sort.go

@@ -1,22 +1,24 @@
-//Package sorts a package for demonstrating sorting algorithms in Go
-package sorts
-
-func bubbleSort(arrayzor []int) {
-
-	swapped := true
-	for swapped {
-		swapped = false
-		for i := 0; i < len(arrayzor)-1; i++ {
-			if arrayzor[i+1] < arrayzor[i] {
-				swap(arrayzor, i, i+1)
-				swapped = true
-			}
-		}
-	}
-}
-
-func swap(arrayzor []int, i, j int) {
-	tmp := arrayzor[j]
-	arrayzor[j] = arrayzor[i]
-	arrayzor[i] = tmp
-}
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
+
+func bubbleSort(arrayzor []int) []int {
+
+
+	swapped := true
+	for swapped {
+		swapped = false
+		for i := 0; i < len(arrayzor)-1; i++ {
+			if arrayzor[i+1] < arrayzor[i] {
+				swap(arrayzor, i, i+1)
+				swapped = true
+			}
+		}
+	}
+	return arrayzor
+}
+
+func swap(arrayzor []int, i, j int) {
+	tmp := arrayzor[j]
+	arrayzor[j] = arrayzor[i]
+	arrayzor[i] = tmp
+}

sorts/heap_sort.go

@@ -1,10 +1,6 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-import (
-	"fmt"
-)
-
 type MaxHeap struct {
 	slice    []int
 	heapSize int
@@ -44,12 +40,12 @@ func heapSort(slice []int) []int {
 		h.slice[0], h.slice[i] = h.slice[i], h.slice[0]
 		h.heapSize--
 		h.MaxHeapify(0)
-		if i == len(h.slice)-1 || i == len(h.slice)-3 || i == len(h.slice)-5 {
+		/*if i == len(h.slice)-1 || i == len(h.slice)-3 || i == len(h.slice)-5 {
 			element := (i - len(h.slice)) * -1
 			fmt.Println("Heap after removing ", element, " elements")
 			fmt.Println(h.slice)
 
-		}
+		}*/
 	}
 	return h.slice
 }

sorts/selection_sort.go

@@ -1,20 +1,19 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-func selectionSort(arr []int) {
-	var min int = 0
-	var tmp int = 0
+func selectionSort(arr []int) []int {
 
 	for i := 0; i < len(arr); i++ {
-		min = i
+		min := i
 		for j := i + 1; j < len(arr); j++ {
 			if arr[j] < arr[min] {
 				min = j
 			}
 		}
 
-		tmp = arr[i]
+		tmp := arr[i]
 		arr[i] = arr[min]
 		arr[min] = tmp
 	}
+	return arr
 }

sorts/shell_sort.go

@@ -1,12 +1,13 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-func shellSort(arr []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 {
 				arr[j], arr[j-d] = arr[j-d], arr[j]
 			}
 		}
 	}
+	return arr
 }

sorts/sorts_case_test.go

@@ -13,7 +13,8 @@ type sortTest struct {
 	name     string
 }
 
-var arr []int = makeRandArray(1_000_000)
+var arr []int = makeRandArray(500_000)
+
 
 var sortTests = []sortTest{
 	//Sorted slice
@@ -26,7 +27,8 @@ var sortTests = []sortTest{
 	{[]int{}, []int{}, "Empty"},
 	//Single-entry slice
 	{[]int{1}, []int{1}, "Singleton"},
-	//1M values sort
+  
+	//500k values sort
 	{arr, getSortedVersion(arr), "Large Random"},
 }
 

sorts/sorts_test.go

@@ -3,6 +3,46 @@ package sorts
 import "testing"
 
 //BEGIN TESTS
+
+func TestBubble(t *testing.T) {
+	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.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)
+		}
+	}
+}
+
+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)
+		}
+	}
+}
+
 func TestMerge(t *testing.T) {
 	for _, test := range sortTests {
 		actual := Mergesort(test.input)
@@ -16,9 +56,85 @@ func TestMerge(t *testing.T) {
 	}
 }
 
+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)
+		}
+	}
+}
+
+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)
+		}
+	}
+}
+
+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)
+		}
+	}
+}
+
+/*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)
+		}
+	}
+}*/
+
 //END TESTS
 
 //BEGIN BENCHMARKS
+func BenchmarkBubble(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			bubbleSort(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++ {
+		for _, test := range sortTests {
+			insertionSort(test.input)
+		}
+	}
+}
+
 func BenchmarkMerge(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		for _, test := range sortTests {
@@ -27,6 +143,38 @@ func BenchmarkMerge(b *testing.B) {
 	}
 }
 
+func BenchmarkHeap(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			heapSort(test.input)
+		}
+	}
+}
+
+func BenchmarkQuick(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			quickSort(test.input)
+		}
+	}
+}
+
+func BenchmarkShell(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			shellSort(test.input)
+		}
+	}
+}
+
+/*func BenchmarkTopological(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		for _, test := range sortTests {
+			topologicalSort(test.input)
+		}
+	}
+}*/
+
 //END BENCHMARKS
 
 func compareSlices(a []int, b []int) (int, bool) {

sorts/topological_sort.go

@@ -1,7 +1,7 @@
 //Package sorts a package for demonstrating sorting algorithms in Go
 package sorts
 
-type Dependency struct {
+/*type Dependency struct {
 	nodeId   int
 	children []int
 }
@@ -81,7 +81,7 @@ func topologicalSort(input []Edge) ([]int, [][]int) {
 		levels = append(levels, level)
 	}
 	return res, levels
-}
+}*/
 
 /*func main() {
 	var edges []Edge