八大基础排序算法Golang代码

> 这里只是给大家(也是给自己)排序的实现代码，并没有什么原理解释
复制代码

• 一方面是因为自己全部写完之后，就懒了
• 另外我觉得，毕竟自己写的golang自带的排序算法性能差距很大，如果追求效率还是用现成的好
• 当然，如果有兴趣就看看也是可以的，毕竟自己菜，导致写这还了一点时间，3Q

冒泡排序

func Bubble_sort(arr []int)  {
	for i := 0; i < len(arr)-1; i++ {
		flag := true
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = false
			}
		}
		if flag {
			break
		}
	}
}
复制代码

选择排序

func Select_sort(arr []int)  {
   for i := 0; i < len(arr)-1; i++ {
   	min := i
   	for j := i + 1; j < len(arr); j++ {
   		if arr[min] > arr[j] {
   			min = j
   		}
   	}
   	if min != i {
   		arr[i], arr[min] = arr[min], arr[i]
   	}
   }
}
复制代码

插入排序

func Insert_sort(arr []int)  {
	for i := 1; i < len(arr); i++ {
		temp := arr[i]
		var j int
		for j = i - 1; j >= 0 && arr[j] >= temp; j-- {
			arr[j+1] = arr[j]
		}
		arr[j+1] = temp
	}
}
复制代码

希尔排序

func Shell_sort(arr []int)  {
	ins := len(arr)
	for ins > 1 {
		ins = ins/3 + 1
		for i := 0; i < ins; i++ {
			for j := i + ins; j < len(arr); j += ins {
				temp := arr[j]
				var k int
				for k = j - ins; k >= 0 && arr[k] >= temp; k -= ins {
					arr[k+ins] = arr[k]
				}
				arr[k+ins] = temp
			}
		}
	}
}
复制代码

快速排序

func Quick_sort(arr[] int,start int,end int) {
	if start<end {
		middle:=Quick_core(arr,start,end)
		Quick_sort(arr,start,middle)
		Quick_sort(arr,middle+1,end)
	}
}
func Quick_core(arr[] int,left int,right int) int{
	for left<right{
		for left<right && arr[right]>=arr[left]{
			right--
		}
		if left<right{
			arr[left],arr[right]=arr[right],arr[left]
			left++
		}
		for left<right && arr[left]<=arr[right] {
			left++
		}
		if left<right {
			arr[left],arr[right]=arr[right],arr[left]
			right--
		}
	}
	return left
}
复制代码

归并排序

func Merge_sort(arr[] int,start int,end int){
	if start<end{
		middle:=(start+end)/2
		Merge_sort(arr,start,middle)
		Merge_sort(arr,middle+1,end)
		Merge_core(arr,start,middle,end)
	}
}
func Merge_core(arr[] int,start int, middle int, end int){
	var temp []int
	a,b:=start,middle+1
	for a<=middle&&b<=end{
		if arr[a]<arr[b]{
			temp=append(temp,arr[a])
			a++
		}else{
			temp=append(temp,arr[b])
			b++
		}
	}
	for a<=middle{
		temp=append(temp,arr[a])
		a++
	}
	for b<=end{
		temp=append(temp,arr[b])
		b++
	}
	for i := 0; i < len(temp); i++ {
		arr[start+i]=temp[i]
	}
}
复制代码

堆排序

func Heap_sort(arr[] int){
	n:=len(arr)
	for i := n-1; i > 0; i-- {
		noleaf:=(i+1)/2-1
		for j:=noleaf;j>=0;j--{
			HeapAdjust(arr,j,i)
		}
		arr[0],arr[i]=arr[i],arr[0]
	}

}
func HeapAdjust(arr[] int,nodeN int,i int){
	lchild:=2*nodeN+1
	rchild:=lchild+1
	max:=nodeN
	if lchild<=i && arr[lchild]>arr[max]{
		max=lchild
	}
	if rchild<=i && arr[rchild]>arr[max]{
		max=rchild
	}
	if max!=nodeN{
		arr[nodeN],arr[max]=arr[max],arr[nodeN]
		HeapAdjust(arr,lchild,i)
		HeapAdjust(arr,rchild,i)
	}
}
复制代码

基数排序

func Radix_sort(arr[] int) []int{
	if len(arr)<2{
        return arr
    }
    maxl:=MaxLen(arr)
    return RadixCore(arr,0,maxl)
}
func RadixCore(arr []int,digit,maxl int) []int{   
    if digit>=maxl{
        return arr                                              
    }
    radix:=10
    count:=make([]int,radix)
    bucket:=make([]int,len(arr))
    for i:=0;i<len(arr);i++{
        count[GetDigit(arr[i],digit)]++
    }
    for i:=1;i<radix;i++{
        count[i]+=count[i-1]
    }
    for i:=len(arr)-1;i>=0;i--{
        d:=GetDigit(arr[i],digit)
        bucket[count[d]-1]=arr[i]
        count[d]--
    }
    return RadixCore(bucket,digit+1,maxl)
}
func GetDigit(x,d int) int{                          
    a:=[]int{1,10,100,1000,10000,100000,1000000}
    return (x/a[d])%10
}
func MaxLen(arr []int) int{                 
    var maxl,curl int
    for i:=0;i<len(arr);i++{
        curl=len(strconv.Itoa(arr[i]))
        if curl>maxl{
            maxl=curl
        }
    }
    return maxl
}
复制代码