scratch @ 4eff1ebb0d1633167671e5370c2bd4e803d72c83

···
        
        1
        +package algos

      
        
        2
        +

      
        
        3
        +func partition(inp []int, lo, hi int) int {

      
        
        4
        +	pivot := inp[hi] // might result in O(n^2)

      
        
        5
        +

      
        
        6
        +	idx := lo - 1

      
        
        7
        +	for i := lo; i < hi; i++ {

      
        
        8
        +		if inp[i] <= pivot {

      
        
        9
        +			idx++

      
        
        10
        +			inp[i], inp[idx] = inp[idx], inp[i]

      
        
        11
        +		}

      
        
        12
        +	}

      
        
        13
        +

      
        
        14
        +	idx++

      
        
        15
        +	inp[hi], inp[idx] = inp[idx], pivot

      
        
        16
        +	return idx

      
        
        17
        +}

      
        
        18
        +

      
        
        19
        +func qs(inp []int, lo, hi int) {

      
        
        20
        +	if lo >= hi {

      
        
        21
        +		return

      
        
        22
        +	}

      
        
        23
        +

      
        
        24
        +	pivot := partition(inp, lo, hi)

      
        
        25
        +	qs(inp, lo, pivot-1)

      
        
        26
        +	qs(inp, pivot+1, hi)

      
        
        27
        +}

      
        
        28
        +

      
        
        29
        +func QuickSort(input []int) { qs(input, 0, len(input) - 1) }

      

···
        
        1
        +package algos

      
        
        2
        +

      
        
        3
        +import (

      
        
        4
        +	"reflect"

      
        
        5
        +	"testing"

      
        
        6
        +)

      
        
        7
        +

      
        
        8
        +func TestQuicksort(t *testing.T) {

      
        
        9
        +	inp := []int{9, 3, 7, 4, 69, 420, 42}

      
        
        10
        +	out := []int{3, 4, 7, 9, 42, 69, 420}

      
        
        11
        +

      
        
        12
        +	QuickSort(inp)

      
        
        13
        +	if !reflect.DeepEqual((inp), out) {

      
        
        14
        +		t.Fatalf("i fucked up")

      
        
        15
        +	}

      
        
        16
        +}