init go implementation

Author: Hawstein

.gitignore

@@ -2,3 +2,7 @@
 .idea
 *.iml
 target
+
+# go
+go/.idea
+

go/Readme.md

@@ -0,0 +1,21 @@
+# Algocasts sorting-algorithem(Go version)
+
+
+## usage
+
+### precondition
+1. go version >= 1.11
+2. go mod is enabled (if not enable, google how to enable )
+
+### usage 
+1. go mod download
+2. use cmd like this to run test 
+
+(using go mod somehow can't use goland test button to run test ,  this problem will be solve later) 
+```
+go test mergesort_test.go mergesort.go
+```
+
+
+
+

go/go.mod

@@ -0,0 +1,5 @@
+module sorting-algorithems
+
+go 1.12
+
+require github.com/stretchr/testify v1.3.0

go/go.sum

@@ -0,0 +1,7 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

go/src/algocasts/insertsort.go

@@ -0,0 +1,16 @@
+package algocasts
+
+func insertsort(input []int) {
+	if input == nil || len(input) == 0 {
+		return
+	}
+	for i := 1; i < len(input); i++ {
+		cur := input[i]
+		j := i - 1
+		for j >= 0 && input[j] > cur {
+			input[j+1] = input[j]
+			j -= 1
+		}
+		input[j+1] = cur
+	}
+}

go/src/algocasts/insertsort_test.go

@@ -0,0 +1,22 @@
+package algocasts
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestInsertSort(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []int
+		want  []int
+	}{
+		{"double", []int{2, 1}, []int{1, 2}},
+		{"single", []int{1, 5, 4}, []int{1, 4, 5}},
+		{"normal", []int{1, 9, 5, 3, 2, 6}, []int{1, 2, 3, 5, 6, 9}},
+	}
+	for _, tt := range tests {
+		insertsort(tt.input)
+		assert.Equal(t, tt.input, tt.want)
+	}
+}

go/src/algocasts/mergesort.go

@@ -0,0 +1,67 @@
+package algocasts
+
+func merge(array []int, low int, mid int, high int, tmp []int) {
+	var i, j, k int = low, mid + 1, 0
+	for i <= mid && j <= high {
+		if array[i] > array[j] {
+			tmp[k] = array[j]
+			k += 1
+			j += 1
+		} else {
+			tmp[k] = array[i]
+			k += 1
+			i += 1
+		}
+	}
+	for i <= mid {
+		tmp[k] = array[i]
+		k += 1
+		i += 1
+	}
+	for j <= high {
+		tmp[k] = array[j]
+		k += 1
+		j += 1
+	}
+	copy(array[low:low+k], tmp[0:k])
+}
+
+func mergeSort(array []int, low int, high int, tmp []int) {
+	if low < high {
+		mid := low + (high-low)/2
+		mergeSort(array, low, mid, tmp)
+		mergeSort(array, mid+1, high, tmp)
+		merge(array, low, mid, high, tmp)
+	}
+}
+
+func MergeSortRecursive(input []int) {
+	if input == nil || len(input) == 0 {
+		return
+	}
+	tmp := make([]int, len(input))
+	mergeSort(input, 0, len(input)-1, tmp)
+}
+
+func min(a, b int) int {
+	if a > b {
+		return b
+	} else {
+		return a
+	}
+}
+
+func mergerSortIterative(input []int) {
+	if input == nil || len(input) == 0 {
+		return
+	}
+	var length int
+	tmp := make([]int, len(input))
+	for length = 1; length < len(input); length *= 2 {
+		for low := 0; low < len(input); low += 2 * length {
+			mid := min(low+length-1, len(input)-1)
+			high := min(low+2*length-1, len(input)-1)
+			merge(input, low, mid, high, tmp)
+		}
+	}
+}

go/src/algocasts/mergesort_test.go

@@ -0,0 +1,38 @@
+package algocasts
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMergeSortRecursive(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []int
+		want  []int
+	}{
+		{"double", []int{2, 1}, []int{1, 2}},
+		{"single", []int{1, 5, 4}, []int{1, 4, 5}},
+		{"normal", []int{1, 9, 5, 3, 2, 6}, []int{1, 2, 3, 5, 6, 9}},
+	}
+	for _, tt := range tests {
+		MergeSortRecursive(tt.input)
+		assert.Equal(t, tt.input, tt.want)
+	}
+}
+
+func TestMergeSortIterative(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []int
+		want  []int
+	}{
+		{"double", []int{2, 1}, []int{1, 2}},
+		{"single", []int{1, 5, 4}, []int{1, 4, 5}},
+		{"normal", []int{1, 9, 5, 3, 2, 6}, []int{1, 2, 3, 5, 6, 9}},
+	}
+	for _, tt := range tests {
+		mergerSortIterative(tt.input)
+		assert.Equal(t, tt.input, tt.want)
+	}
+}

go/src/algocasts/quicksort.go

@@ -0,0 +1,64 @@
+package algocasts
+
+func lomutopartition(input []int, low, high int) int {
+	pivot := input[high]
+	i := low
+	for j := low; j <= high; j++ {
+		if input[j] < pivot {
+			swap(input, i, j)
+			i += 1
+		}
+	}
+	swap(input, i, high)
+	return i
+}
+
+func lomutosort(input []int, low, high int) {
+	if low < high {
+		k := lomutopartition(input, low, high)
+		lomutosort(input, low, k-1)
+		lomutosort(input, k+1, high)
+	}
+}
+
+func Lomutosort(input []int) {
+	if input == nil || len(input) == 0 {
+		return
+	}
+	lomutosort(input, 0, len(input)-1)
+}
+
+func partition(input []int, low, high int) int {
+	mid := low + (high-low)/2
+	pivot := input[mid]
+	var i, j = low, high
+	for true {
+		for input[i] < pivot {
+			i += 1
+		}
+		for input[j] > pivot {
+			j -= 1
+		}
+		if i >= j {
+			return j
+		}
+		swap(input, i, j)
+	}
+	return j
+}
+
+func quicksort(input []int, low, high int) {
+	if low >= high {
+		return
+	}
+	k := partition(input, low, high)
+	quicksort(input, low, k)
+	quicksort(input, k+1, high)
+}
+
+func Quicksort(input []int) {
+	if input == nil || len(input) == 0 {
+		return
+	}
+	quicksort(input, 0, len(input)-1)
+}

go/src/algocasts/quicksort_test.go

@@ -0,0 +1,38 @@
+package algocasts
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestQuickSort(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []int
+		want  []int
+	}{
+		{"double", []int{2, 1}, []int{1, 2}},
+		{"single", []int{1, 5, 4}, []int{1, 4, 5}},
+		{"normal", []int{1, 9, 5, 3, 2, 6}, []int{1, 2, 3, 5, 6, 9}},
+	}
+	for _, tt := range tests {
+		Quicksort(tt.input)
+		assert.Equal(t, tt.input, tt.want)
+	}
+}
+
+func TestLomutoSort(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []int
+		want  []int
+	}{
+		{"double", []int{2, 1}, []int{1, 2}},
+		{"single", []int{1, 5, 4}, []int{1, 4, 5}},
+		{"normal", []int{1, 9, 5, 3, 2, 6}, []int{1, 2, 3, 5, 6, 9}},
+	}
+	for _, tt := range tests {
+		Lomutosort(tt.input)
+		assert.Equal(t, tt.input, tt.want)
+	}
+}