Zgo - Sort Algorithms

sort.go

package algorithms

func MergeSort(items []int) []int {
    n := len(items)
    var combined []int
    switch {
    case n <= 1:
        combined = items
    case n == 2:
        if items[0] <= items[1] {
            combined = items
        } else {
            combined = append(combined, items[1], items[0])
        }
    case n > 2:
        left := MergeSort(items[0 : n/2])
        right := MergeSort(items[n/2:])
        i := 0
        j := 0
        for i <= len(left) || j <= len(right) {
            switch {
            case left[i] == right[j]:
                combined = append(combined, left[i], right[j])
                i++
                j++
            case left[i] < right[j]:
                combined = append(combined, left[i])
                i++
            case right[j] < left[i]:
                combined = append(combined, right[j])
                j++
            }

            if i == len(left) {
                combined = append(combined, right[j:]...)
                break
            }

            if j == len(right) {
                combined = append(combined, left[i:]...)
                break
            }
        }
    }
    return combined
}

func QuickSort(items []int) []int {
    n := len(items)
    var sorted []int

    switch {
    case n <= 1:
        sorted = items
    case n == 2:
        if items[0] <= items[1] {
            sorted = items
        } else {
            sorted = append(sorted, items[1], items[0])
        }
    case n > 2:
        pivot := items[0]
        var left []int
        var middle = []int{pivot}
        var right []int
        for i := 1; i < n; i ++ {
            switch {
            case items[i] < pivot:
                left = append(left, items[i])
            case items[i] == pivot:
                middle = append(middle, items[i])
            case items[i] > pivot:
                right = append(right, items[i])
            }
        }
        left = QuickSort(left)
        right = QuickSort(right)
        sorted = append(sorted, left...)
        sorted = append(sorted, middle...)
        sorted = append(sorted, right...)
    }

    return sorted
}

 

sort_test.go

package algorithms

import (
    "reflect"
    "testing"
)

type TestCase struct {
    name     string
    input    any
    expected any
}

func getSortTests() []TestCase {
    tests := []TestCase{
        {"Case 1", []int{31, 27, 3, 54, 6, 9, 12, 8}, []int{3, 6, 8, 9, 12, 27, 31, 54}},
        {"Case 2", []int{4, 3, 5, 3, 2, 2}, []int{2, 2, 3, 3, 4, 5}},
        {"Case 3", []int{3, 5, 8, 4, 3}, []int{3, 3, 4, 5, 8}},
        {"Case 4", []int{}, []int{}},
    }
    return tests
}

func TestMergeSort(t *testing.T) {
    tests := getSortTests()
    for _, tc := range tests {
        sorted := MergeSort(tc.input.([]int))
        if !reflect.DeepEqual(sorted, tc.expected) {
            t.Errorf("%s failed. Input: %v Output: %v Expected: %v", tc.name, tc.input, sorted, tc.expected)
        }
    }
}

func TestQuickSort(t *testing.T) {
    tests := getSortTests()
    for _, tc := range tests {
        sorted := QuickSort(tc.input.([]int))
        if !reflect.DeepEqual(sorted, tc.expected) {
            t.Errorf("%s failed. Input: %v Output: %v Expected: %v", tc.name, tc.input, sorted, tc.expected)
        }
    }
}