Removed main from all sort functions, changed packages to "sorts" package (#100)

* 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

Author: c4llmeco4ch

.github/workflows/golangci-lint.yml

@@ -18,4 +18,4 @@ jobs:
     - run: ./bin/golangci-lint run --no-config dynamic-programming || true
     - run: ./bin/golangci-lint run --no-config other               || true
     - run: ./bin/golangci-lint run --no-config searches            || true
-    - run: ./bin/golangci-lint run --no-config sorts               || true
+    - run: ./bin/golangci-lint run --no-config sorts

sorts/InsertionSort.go

@@ -1,33 +1,22 @@
-package main
-
-import (
-	"fmt"
-)
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
 func bubbleSort(arrayzor []int) {
 
-	swapped := true;
+	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)
+		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) {
+func swap(arrayzor []int, i, j int) {
 	tmp := arrayzor[j]
 	arrayzor[j] = arrayzor[i]
 	arrayzor[i] = tmp
 }
-
-func main() {
-
-	arrayzor := []int{1, 6, 2, 4, 9, 0, 5, 3, 7, 8}
-	fmt.Println("Unsorted array: ", arrayzor)
-	bubbleSort(arrayzor)
-	fmt.Println("Sorted array: ", arrayzor)
-}

sorts/SelectionSort.go

@@ -1,8 +1,9 @@
-package main
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
-import "fmt"
-import "math/rand"
-import "time"
+import (
+	"fmt"
+)
 
 type MaxHeap struct {
 	slice    []int
@@ -52,21 +53,3 @@ func heapSort(slice []int) []int {
 	}
 	return h.slice
 }
-
-func main() {
-	s1 := rand.NewSource(time.Now().UnixNano())
-	r1 := rand.New(s1)
-	s := make([]int, 20)
-	for index, _ := range s {
-		s[index] = r1.Intn(400)
-	}
-	fmt.Println("Randomly generated array:")
-	fmt.Println(s)
-	h := BuildMaxHeap(s)
-	fmt.Println("\nInital Heap: ")
-	fmt.Println(h.slice, "\n")
-
-	s = heapSort(s)
-	fmt.Println("\nFinal List:")
-	fmt.Println(s)
-}

sorts/bubble_sort.go

@@ -1,10 +1,7 @@
-package main
-
-import "fmt"
-
-func main() {
-	arr := [9]int{2, 1, 4, 3, 5, 9, 7, 6, 8}
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
+func insertionSort(arr []int) []int {
 	for out := 1; out < len(arr); out++ {
 		temp := arr[out]
 		in := out
@@ -14,8 +11,5 @@ func main() {
 		}
 		arr[in] = temp
 	}
-
-	for _, sortedvals := range arr {
-		fmt.Println(sortedvals)
-	}
+	return arr
 }

sorts/Heapsort.go renamed to sorts/heap_sort.go

@@ -1,48 +1,48 @@
-package main
-
-import "fmt"
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
 func merge(a []int, b []int) []int {
 
-  var r = make([]int, len(a) + len(b))
-  var i = 0
-  var j = 0
-
-  for i < len(a) && j < len(b) {
-  
-    if a[i] <= b[j] {
-      r[i+j] = a[i]
-      i++
-    } else {
-      r[i+j] = b[j]
-      j++
-    }
-    
-  }
-
-  for i < len(a) { r[i+j] = a[i]; i++ }
-  for j < len(b) { r[i+j] = b[j]; j++ }
-
-  return r
-  
+	var r = make([]int, len(a)+len(b))
+	var i = 0
+	var j = 0
+
+	for i < len(a) && j < len(b) {
+
+		if a[i] <= b[j] {
+			r[i+j] = a[i]
+			i++
+		} else {
+			r[i+j] = b[j]
+			j++
+		}
+
+	}
+
+	for i < len(a) {
+		r[i+j] = a[i]
+		i++
+	}
+	for j < len(b) {
+		r[i+j] = b[j]
+		j++
+	}
+
+	return r
+
 }
 
+//Mergesort Perform mergesort on a slice of ints
 func Mergesort(items []int) []int {
 
-  if len(items) < 2 {
-    return items
-    
-  }
+	if len(items) < 2 {
+		return items
 
-  var middle = len(items) / 2
-  var a = Mergesort(items[:middle])
-  var b = Mergesort(items[middle:])
-  return merge(a, b)
-  
-}
+	}
 
-func main () {
+	var middle = len(items) / 2
+	var a = Mergesort(items[:middle])
+	var b = Mergesort(items[middle:])
+	return merge(a, b)
 
-  fmt.Print(Mergesort([]int{ 10, 9, 8, 4, 5, 6, 7, 3, 2, 1 }), "\n")
-  
 }

sorts/insertion_sort.go

@@ -1,53 +1,38 @@
-package main
-
-import "fmt"
-import "math/rand"
-
-
-func quick_sort(arr []int) []int {
-    
-    if len(arr) <= 1 {
-        return arr
-    }
- 
-    median := arr[rand.Intn(len(arr))]
-    
-    low_part := make([]int, 0, len(arr))
-    high_part := make([]int, 0, len(arr))
-    middle_part := make([]int, 0, len(arr))
- 
-    for _, item := range arr {
-        switch {
-        case item < median:
-            low_part = append(low_part, item)
-        case item == median:
-            middle_part = append(middle_part, item)
-        case item > median:
-            high_part = append(high_part, item)
-        }
-    }
- 
-    low_part = quick_sort(low_part)
-    high_part = quick_sort(high_part)
-
-    low_part = append(low_part, middle_part...)
-    low_part = append(low_part, high_part...)
- 
-    return low_part
-}
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
-func main() {
-    arr := RandomArray(10)
+import (
+	"math/rand"
+)
 
-    fmt.Println("Initial array is:", arr)
-    fmt.Println("")
-    fmt.Println("Sorted array is: ", quick_sort(arr))
-}
+func quickSort(arr []int) []int {
+
+	if len(arr) <= 1 {
+		return arr
+	}
+
+	median := arr[rand.Intn(len(arr))]
+
+	low_part := make([]int, 0, len(arr))
+	high_part := make([]int, 0, len(arr))
+	middle_part := make([]int, 0, len(arr))
 
-func RandomArray(n int) []int {
-    arr := make([]int, n)
-    for i := 0; i <= n - 1; i++ {
-        arr[i] = rand.Intn(n)
-    }
-    return arr
-}
+	for _, item := range arr {
+		switch {
+		case item < median:
+			low_part = append(low_part, item)
+		case item == median:
+			middle_part = append(middle_part, item)
+		case item > median:
+			high_part = append(high_part, item)
+		}
+	}
+
+	low_part = quickSort(low_part)
+	high_part = quickSort(high_part)
+
+	low_part = append(low_part, middle_part...)
+	low_part = append(low_part, high_part...)
+
+	return low_part
+}

sorts/merge_sort.go

@@ -1,29 +1,20 @@
-package main
+//Package sorts a package for demonstrating sorting algorithms in Go
+package sorts
 
+func selectionSort(arr []int) {
+	var min int = 0
+	var tmp int = 0
 
-import "fmt"
+	for i := 0; i < len(arr); i++ {
+		min = i
+		for j := i + 1; j < len(arr); j++ {
+			if arr[j] < arr[min] {
+				min = j
+			}
+		}
 
-
-func main() {
-	arr := [5]int{11, 12, 31, 4, 1}
-    fmt.Println("Initial array is:", arr)
-    fmt.Println("")
-
-    var min int = 0
-    var tmp int = 0
-
-    for i := 0; i < len(arr); i++ {
-        min = i
-        for j := i + 1; j < len(arr); j++ {
-            if arr[j] < arr[min] {
-                min = j
-            }
-        }
-		
-        tmp = arr[i]
-        arr[i] = arr[min]
-        arr[min] = tmp
-    }
-
-    fmt.Println("Sorted array:    ", arr)
-}
+		tmp = arr[i]
+		arr[i] = arr[min]
+		arr[min] = tmp
+	}
+}