add sleepsort and odd-even-sort

Author: SimonWaldherr

sort/oddevensort.go

@@ -0,0 +1,39 @@
+// oddevensort.go
+// Implementation of Odd-Even Sort (Brick Sort)
+// Reference: https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort
+
+package sort
+
+import "github.com/TheAlgorithms/Go/constraints"
+
+// OddEvenSort performs the odd-even sort algorithm on the given array.
+// It is a variation of bubble sort that compares adjacent pairs, alternating
+// between odd and even indexed elements in each pass until the array is sorted.
+func OddEvenSort[T constraints.Ordered](arr []T) []T {
+	if len(arr) == 0 { // handle empty array
+		return arr
+	}
+
+	swapped := true
+	for swapped {
+		swapped = false
+
+		// Perform "odd" indexed pass
+		for i := 1; i < len(arr)-1; i += 2 {
+			if arr[i] > arr[i+1] {
+				arr[i], arr[i+1] = arr[i+1], arr[i]
+				swapped = true
+			}
+		}
+
+		// Perform "even" indexed pass
+		for i := 0; i < len(arr)-1; i += 2 {
+			if arr[i] > arr[i+1] {
+				arr[i], arr[i+1] = arr[i+1], arr[i]
+				swapped = true
+			}
+		}
+	}
+
+	return arr
+}

sort/sleepsort.go

@@ -0,0 +1,53 @@
+// sleepsort.go
+// Implementation of Sleep Sort algorithm (mostly as a fun experiment)
+// Note: This is not a practical sorting algorithm and relies on goroutines and time.Sleep
+// Reference: https://en.wikipedia.org/wiki/Sorting_algorithm#Sleep_sort
+
+package sort
+
+import (
+	"sync"
+	"time"
+)
+
+// SleepSort performs the sleep sort algorithm on the given array.
+// It uses goroutines to "sort" by sleeping for a duration proportional to each element's value.
+// WARNING: Not suitable for production or large numbers, as it is inefficient and can cause timing issues.
+func SleepSort(arr []int) []int {
+	if len(arr) == 0 { // handle empty array
+		return arr
+	}
+
+	var wg sync.WaitGroup
+	resultChan := make(chan int, len(arr))
+
+	for _, num := range arr {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			time.Sleep(time.Duration(n) * time.Millisecond) // sleep for n milliseconds
+			resultChan <- n
+		}(num)
+	}
+
+	// Wait for all goroutines to finish
+	go func() {
+		wg.Wait()
+		close(resultChan)
+	}()
+
+	// Collect sorted results
+	var result []int
+	for num := range resultChan {
+		result = append(result, num)
+	}
+
+	return result
+}
+
+// Example usage:
+// func main() {
+//     arr := []int{3, 1, 4, 2}
+//     sortedArr := SleepSort(arr)
+//     fmt.Println(sortedArr) // Output may vary based on timing accuracy
+// }

sort/sorts_test.go

@@ -194,6 +194,15 @@ func TestCircle(t *testing.T) {
 	testFramework(t, sort.Circle[int])
 }
 
+func TestSleepSort(t *testing.T) {
+	t.Skip("Skipping test for Sleep Sort, as it is not a normal sort algorithm and it doesn't support negative values.")
+	//testFramework(t, sort.SleepSort)
+}
+
+func TestOddEvenSort(t *testing.T) {
+	testFramework(t, sort.OddEvenSort[int])
+}
+
 // END TESTS
 
 func benchmarkFramework(b *testing.B, f func(arr []int) []int) {