golang实现选择排序，快速排序，希尔排序，堆排序，快速排序,归并排序

func max_heapify(dad int , end int , arr []int){
	son := dad * 2 + 1
	for son <= end{
		if son + 1 <= end && arr[son] < arr[son+1]{
			son = son + 1
		}
		if arr[dad] >= arr[son]{
			return
		}else{
			arr[dad],arr[son] = arr[son],arr[dad]
			dad = son
			son = dad * 2 + 1
		}
	}
}
func heap_sort(arr []int ){
	for i := len(arr) / 2; i >= 0 ; i--{
		max_heapify(i,len(arr)-1,arr)
	}
	for i := len(arr)-1 ; i >= 0 ; i--{
		arr[i],arr[0] = arr[0],arr[i]
		max_heapify(0,i-1,arr)
	}
}

func mergeSort(left int , right int , arr []int)[]int{

	if len(arr)==1{
		return arr
	}
	mid := (left + right)/2

	a1  := mergeSort(left,mid,arr[0:mid+1-left])
	a2  := mergeSort(mid+1,right,arr[mid+1-left:])


	len1 := len(a1)
	len2 := len(a2)

	temp := make([]int,0)
	for i,j := 0,0;i < len1 || j < len2 ;{
		if i == len1{
			temp = append(temp , a2[j])
			j++
			continue
		}
		if j == len2{
			temp = append(temp , a1[i])
			i++
			continue
		}
		if a1[i] < a2[j]{
			temp = append(temp , a1[i])
			i++
		}else{
			temp = append(temp , a2[j])
			j++
		}
	}
	return temp
}

func shellSort(){
	l := len(s)
	for ;l >  1;{
		l = l / 2
		for i := 0 ; i < l ; i++{
			for j := i ; j < len(s) ; j += l{
				for k := j ; k > i ; k -= l{
					if s[k-1] > s[k]{
						s[k],s[k-1] = s[k-1],s[k]
					}else{
						break
					}
				}
			}
		}
	}
}

func selectSort(){
	 for i := 0 ; i < len(s) ; i++{
	 	index := i
	 	for j := i + 1 ; j < len(s) ; j++{
	 		if s[index] > s[j]{
	 			index = j
			}
		}
	 	s[i],s[index] = s[index],s[i]
	 }
}

func BubbleSort(){
	for i := 0 ; i < len(s) ; i++{
		for j := len(s)-1 ; j > i ; j--{
			if s[j] < s[j-1]{
				s[j],s[j-1] = s[j-1],s[j]
			}
		}
	}
}

func quickSort(s []int,left int , right int ){
	/*
		任何时刻指向的都是小于等于s[left]的位置,遇到一个小于left的explodeIndex就会++并且交换，当a[i】<= a[left]的时候，要末和自己交换，要么和第一个大于s【left】的交换
	*/
	if left >= right{
		return
	}
	changeIndex := left
	for i := left + 1 ; i <= right ; i ++{
		if s[i] <= s[left]{
			changeIndex++
			s[i],s[changeIndex] = s[changeIndex],s[i]
		}
	}
	s[changeIndex],s[left] = s[left],s[changeIndex]
	quickSort(s  ,left,changeIndex-1)
	quickSort(s  ,changeIndex+1,right)
}