8대 기본 정렬 알고리즘 Golang 코드

>        (     )       ，         

거품 정렬

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 start1,end)
	}
}
func Quick_core(arr[] int,left int,right int) int{
	for leftfor left=arr[left]{
			right--
		}
		if leftfor leftif leftreturn left
}

병합 정렬

func Merge_sort(arr[] int,start int,end int){
	if start2
		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]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-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
}