Golang排序算法

• 折半插入排序 O(n^2)

func RhInsert(array *[] int) []int{
	length := len(*array)
	for i :=1;i < length;i++{
		if (*array)[i] < (*array)[i-1]{
			low := 0
			high := i - 1
			tmp :=(*array)[i]
			for{
				if low > high{
					break
				}
				mid := (low + high)/2
				if (*array)[mid] > tmp{
					high = mid - 1
				}else{
					low = mid + 1
				}
			}
			for j := i;j > low;j--{
				(*array)[j] = (*array)[j-1]
			}
			(*array)[low] = tmp
		}
	}
	return *array
}

• 选择排序 O(n^2)

func ChooseSort(a *[]int) []int{
	length := len(*a)
	for i:=0;i < length;i++{
		min :=i
		for j :=i+1;j < length;j++{
			if (*a)[j] < (*a)[min]{
				min = j
			}
		}
		if min != i{
			(*a)[i],(*a)[min] = (*a)[min],(*a)[i]
		}
	}
	return *a
}

• 归并排序 O(nlogn)

func MergeSort(a *[]int) []int{
	tmp :=make([]int,len(*a))
	Sort(a,0,len(*a)-1,tmp)
	return *a

}
//归并操作
func Mer(a *[]int,left int,mid int,right int,tmp []int) []int{
	lx := left
	rx := mid + 1
	i:=0
	for{
		if lx > mid || rx > right {
			break
		}
		if (*a)[lx] < (*a)[rx]{
			tmp[i] = (*a)[lx]
			lx = lx + 1
		}else{
			tmp[i] = (*a)[rx]
			rx = rx + 1
		}
		i ++
	}
	for {
		if(lx > mid){
			break
		}
		tmp[i] = (*a)[lx]
		i++;lx++
	}
	for {
		if(rx > right){
			break
		}
		tmp[i] = (*a)[rx]
		i++;rx++
	}
	i = 0
	for {
		if(left > right){
			break
		}
		(*a)[left] = tmp[i]
		i++;left++
	}
	return *a
}
//左右序列不断分化,直到左右只有一个数时为止
func Sort(a *[]int,left int,right int,tmp []int){
	if left < right{
		mid :=(left + right)/2
		Sort(a,left,mid,tmp)
		Sort(a,mid+1,right,tmp)
		Mer(a,left,mid,right,tmp)
	}
}

• 堆排序 O(nlogn)

func HeapSort(a *[]int) []int{
	//构建heap堆 默认大顶堆
	for i := len(*a)/2 - 1; i >= 0; i--{
		ReguHeap(a,i,len(*a))
	}
	//第二步反复交换与重建
	for j :=len(*a) - 1;j > 0 ; j--{
		Swapn(a,0,j)
		ReguHeap(a,0,j)//重构剩余元素
	}
	return *a
}
func ReguHeap(a *[]int,i int,length int){
	tmp := (*a)[i]
	for k := 2*i+1;k < length; k=2*k+1{
		if k + 1 < length && (*a)[k] < (*a)[k+1]{
			k ++
		}
		if (*a)[k] > tmp{
			(*a)[i] = (*a)[k];i = k//直接赋值减少交换次数
		}else{
			break
		}
	}
	(*a)[i] = tmp

}
func Swapn(a *[]int,m int,n int){
	(*a)[m],(*a)[n] = (*a)[n],(*a)[m]
}

• 快速排序 O(logn) ~ O(n^2)

func QuickSort(a *[]int) []int{
	SortIt(a,0,len(*a)-1)
	return *a
}
//对左右进行调节
func Adjust(a *[]int,start int,end int) int{
	tmp := (*a)[start]
	for{
		if start >= end{
			break
		}
		for{
			if end <= start{
				break
			}
			if (*a)[end] > tmp{
				end = end - 1
			}else{
				(*a)[start] = (*a)[end]
				break
			}
		}
		for{
			if start >= end{
				break
			}
			if (*a)[start] < tmp{
				start = start + 1
			}else{
				(*a)[end] = (*a)[start]
				break
			}
		}
		(*a)[start] = tmp
	}
	return start
}
func SortIt(a *[]int,start int,end int){
	if start < end{
		mid := Adjust(a,start,end)
		SortIt(a,start,mid - 1)
		SortIt(a,mid + 1,end)
	}

}

• 计数排序 O(n+k)

func CountSort(a *[]int) []int{
	min :=(*a)[0]
	max :=min
	for _,v := range *a{
		if v > max{
			max = v
		}
		if v < min{
			min = v
		}
	}
	count :=make([]int,max-min+1)
	res :=make([]int,len(*a))
	for _,v :=range *a{
			count[v-min]++
	}
	for i,_:=range count{
		if i !=0{
			count[i] = count[i] + count[i - 1]
		}
	}
	for i :=len(*a)-1;i >= 0;i --{
		count[(*a)[i] - min] --
		tmp :=count[(*a)[i] - min]
		index :=tmp
		res[index] = (*a)[i]
	}
	return res
}