algorithm init

Author: gongwei

.gitignore

@@ -0,0 +1 @@
+.vscode

go.mod

@@ -0,0 +1,3 @@
+module algorithm
+
+go 1.14

mian.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+	"reflect"
+	"strconv"
+	"time"
+
+	selfSort "algorithm/sortAlgorithm"
+)
+
+func main() {
+	testnums := 80000
+	testArr := createArr(testnums)
+	// testArr := []int{5, 1, 3, 4, 5, 7, 8, 9, 10, 32, 22, 18, 17, 25, 22, 11, 12, 22, 12, 33, 44, 44}
+	var re []int
+
+	sort := selfSort.NewSortService()
+	re = sort.Sort.InsertSort(testArr)
+	fmt.Println(re)
+
+	sortValue := reflect.ValueOf(sort.Sort)
+	sortType := reflect.TypeOf(sort.Sort)
+
+	a := reflect.ValueOf(testArr)
+	// aNums := reflect.ValueOf(testnums)
+	in := []reflect.Value{a}
+	// inNums := []reflect.Value{a, aNums}
+	// ret := sortValue.Method(0).Call(in)
+	// fmt.Println(sortType.Method(0).Name == "BubbleSort")
+	// a := sortType.Method(0).
+	// re := a.Method(testArr)
+	// for _, method := range sortType.Method {
+	// 	fmt.Println(method)
+	// }
+	// var re []int
+	// re = selfSort.BubbleSort(testArr)
+	for i := 0; i < sortValue.NumMethod(); i++ {
+		methodName := sortType.Method(i).Name
+		start := time.Now()
+		switch methodName {
+		// case "CountSort":
+		// 	sortValue.MethodByName(methodName).Call(inNums)
+		default:
+			sortValue.MethodByName(methodName).Call(in)
+		}
+		elapsed := time.Since(start)
+		fmt.Printf("method name : %-16s\t elapsed time: %6s\t\t  \n", methodName, elapsed)
+	}
+}
+
+func createArr(nums int) []int {
+	var arr []int = []int{}
+	for i := 0; i < 20000; i++ {
+		randDateString := fmt.Sprintf("%d", rand.New(rand.NewSource(time.Now().UnixNano())).Intn(nums))
+		randDateInt, _ := strconv.Atoi(randDateString)
+		arr = append(arr, randDateInt)
+	}
+	return arr
+
+}

sortAlgorithm/bubbleSort.go

@@ -0,0 +1,154 @@
+package sortalgorithm
+
+type Sort interface {
+	BubbleSort(nums []int) []int
+	FastSort(nums []int) []int
+	InsertSort(arr []int) []int
+	MergeSort(arr []int) []int
+	HeapSort(arr []int) []int
+	CountSort(arr []int) []int
+}
+
+type sortF struct{}
+
+type SortService struct {
+	Sort Sort
+}
+
+func NewSortService() SortService {
+	return SortService{
+		Sort: &sortF{},
+	}
+}
+
+//support BubbleSort
+func (s *sortF) BubbleSort(nums []int) []int {
+	for i := 0; i < len(nums); i++ {
+		for j := i + 1; j < len(nums); j++ {
+			if nums[i] <= nums[j] {
+				continue
+			} else {
+				tmp := nums[j]
+				nums[j] = nums[i]
+				nums[i] = tmp
+			}
+		}
+	}
+	return nums
+}
+
+func (s *sortF) FastSort(nums []int) []int {
+	fastSortIter(0, len(nums)-1, nums)
+	return nums
+}
+
+func fastSortIter(left int, right int, nums []int) {
+	if left < right {
+		key := nums[left]
+		i := left
+		j := right
+		for i < j {
+			for i < j && key < nums[j] {
+				j--
+			}
+			if i < j {
+				nums[i] = nums[j]
+				i++
+			}
+			for i < j && key > nums[i] {
+				i++
+			}
+			if i < j {
+				nums[j] = nums[i]
+				j--
+			}
+		}
+		nums[i] = key
+		fastSortIter(left, i-1, nums)
+		fastSortIter(i+1, right, nums)
+	}
+}
+
+func (s *sortF) InsertSort(arr []int) []int {
+	preIndex := 0
+	curent := 0
+	for i := 1; i < len(arr); i++ {
+		curent = arr[i]
+		preIndex = i - 1
+		for preIndex >= 0 && arr[preIndex] > curent {
+			arr[preIndex+1] = arr[preIndex]
+			preIndex--
+		}
+		arr[preIndex+1] = curent
+	}
+	return arr
+}
+
+func (s *sortF) MergeSort(arr []int) []int {
+	if len(arr) < 2 {
+		return arr
+	}
+	medium := len(arr) / 2
+	left := arr[0:medium]
+	right := arr[medium:]
+
+	return merge(s.MergeSort(left), s.MergeSort(right))
+
+}
+
+func merge(left []int, right []int) []int {
+	var result []int
+	for len(left) != 0 && len(right) != 0 {
+		if left[0] < right[0] {
+			result = append(result, left[0])
+			left = left[1:]
+		} else {
+			result = append(result, right[0])
+			right = right[1:]
+		}
+	}
+	for len(left) != 0 {
+		result = append(result, left[0])
+		left = left[1:]
+	}
+	for len(right) != 0 {
+		result = append(result, right[0])
+		right = right[1:]
+	}
+	return result
+}
+
+func (s *sortF) HeapSort(arr []int) []int {
+	myHeap := newHeap()
+	for _, a := range arr {
+		myHeap.insert(a)
+	}
+	var re []int = []int{}
+	for myHeap.N != 0 {
+		re = append(re, myHeap.pop())
+	}
+	return re
+}
+
+func (s *sortF) CountSort(arr []int) []int {
+	max := arr[0]
+	for i := 0; i < len(arr)-1; i++ {
+		if arr[i] > max {
+			max = arr[i]
+		}
+	}
+	tmp := make([]int, max+1)
+	index := 0
+	for i := 0; i < len(arr)-1; i++ {
+		tmp[arr[i]]++
+	}
+	var re []int = []int{}
+	for index <= max {
+		for tmp[index] > 0 {
+			re = append(re, index)
+			tmp[index]--
+		}
+		index++
+	}
+	return re
+}

sortAlgorithm/heap.go

@@ -0,0 +1,71 @@
+package sortalgorithm
+
+type Myheap interface {
+	sink(i int)
+	swim(i int)
+	insert(v int)
+	pop() int
+}
+
+type selfHeap struct {
+	arr []int
+	N   int
+}
+
+func newHeap() selfHeap {
+	N := 0
+	var arr []int = []int{}
+	arr = append(arr, 0)
+	return selfHeap{
+		arr: arr,
+		N:   N,
+	}
+}
+
+func (h *selfHeap) sink(i int) {
+	for {
+		left := 2 * i
+		right := 2*i + 1
+		min := left
+		if left > h.N {
+			break
+		}
+		if left < h.N && h.arr[right] < h.arr[left] {
+			min = right
+		}
+		if right < h.N && h.arr[i] < h.arr[min] {
+			break
+		}
+		h.swap(h.arr, i, min)
+		i = min
+	}
+
+}
+
+func (h *selfHeap) swim(i int) {
+	for i > 1 && h.arr[i] < h.arr[i/2] {
+		h.swap(h.arr, i, i/2)
+		i = i / 2
+	}
+}
+
+func (h *selfHeap) swap(nums []int, i, j int) {
+	nums[i], nums[j] = nums[j], nums[i]
+}
+
+func (h *selfHeap) insert(v int) {
+	h.arr = append(h.arr, v)
+	h.N++
+	h.swim(h.N)
+}
+
+func (h *selfHeap) pop() int {
+	if h.N == 0 {
+		return 0
+	}
+	min := h.arr[1]
+	h.swap(h.arr, 1, h.N)
+	h.N--
+	h.sink(1)
+	return min
+}