常用排序算法 Go實現

冒泡排序:

分解思想:
1.每次取到最大的數和第i位交換

//取數組最大的數 遍歷一遍數組 找到最大的
func GetMax(arr[] int){
	for j:=1;j<len(arr);j++{
		//找到數組中最小的值 交換到數組的第一位
		if arr[j-1] < arr[j]{
			arr[j-1],arr[j] = arr[j],arr[j-1]
		}
	}
}

2.然後在 對i + 1位重複第一步 不停循環 直到數組尾部

func BubbleSort(arr[] int) []int{
	for i:=0;i<len(arr);i++{
	// 9 5 3 三個數
	//第一次arr[0:] 取 // 9 5 3  調用GetMax()找到 9 那麼第i就改爲 9
	//第二次取arr[1:] /5 3
	//第三次arr[2:] /3 由於只有一位 不需要查找
		maxnum := GetMax(arr[i:])
		arr[i] = maxnum
		fmt.Printf("\n第%d次排序, %v",i,arr)
	}
	return arr
}

//冒泡排序完整版
//適用場景: 對已經有序的數組進行插入  算法複雜度:On
//對於普通場景:On的複雜度
func BubbleSort(arr[] int) []int{
	for i:=0;i<len(arr);i++{
		for j:=i+1;j<len(arr);j++{
			if arr[i] > arr[j]{
			arr[i],arr[j] = arr[j],arr[i]
			}
		}
		fmt.Printf("\n第%d次排序, %v",i,arr)
	}
	return arr
}

堆排序

堆排序 實際就是 一個滿二叉樹 遍歷所有父節點,父節 如果子節點小於 父節點就執行替換。
一顆二叉樹的深度爲:n/2 -1
左節點的位置爲:2n + 1
右節點的位置爲:2n + 2

堆排序代碼

func HeapSort(arr []int,topn int) []int{
	length := len(arr)
	for i:=1;i<=length;i++{
		lastlen := length -i
		HeapSortMax(arr,lastlen)
		if i< length {
			arr[0],arr[lastlen] = arr[lastlen],arr[0]
		}
		if topn - i ==0{
			break
		}
	}
	return arr[len(arr) - topn:]
}

//每次從堆中 取一個最大數 放到 i處


func HeapSortMax(arr[] int,length int) []int{
	if length <= 1{
		return arr
	}else{
		depth := length/2 -1
		for i:=depth;i>=0;i--{
			topmax := i //最大的在i位置
			leftchild := 2 * i + 1
			rightchild := 2 * i + 2
			if leftchild <= length  && arr[leftchild] > arr[topmax]{
				topmax = leftchild
			}
			if rightchild <= length  && arr[rightchild] >arr[topmax]{
				topmax = rightchild
			}
			if topmax != i{
				arr[i],arr[topmax] = arr[topmax],arr[i]
			}

		}
		return arr
	}
}

func main(){
	arr := []int{1,34,54,12,32,12,65,23,67}
	fmt.Println(HeapSortMax(arr,len(arr)))
}

希爾排序

func shellsort(arr []int) []int{
	if len(arr)  <= 1 {
		return arr
	}else{
		gap := len(arr)/2
		for gap > 0{
			for i:=0;i<gap;i++{
				ShellSortStep(arr,i,gap)
			}
			gap/=2
		}
		return arr
	}
}

func ShellSortStep(arr[] int,start int,gap int){
	length := len(arr)
	for i:= start + gap;i<length;i+=gap{
		j := i - gap
		bak := arr[i]
		for j >=0 && bak < arr[j] {
			arr[j + gap] = arr[j]
			j -= gap
		}
		arr[j + gap] =bak


	}


}

希爾排序併發版

func gourtinesort(arr []int){
	if len(arr) <2 || arr == nil{
		return
	}
	cpunum := runtime.NumCPU()
	wg := sync.WaitGroup{}
	for gap := len(arr);gap >0;gap/=2{
		wg.Add(cpunum)
		ch := make(chan int,1000)
		go func(){
			for k:=0;k<gap;k++{
				ch <- k
			}
			close(ch)
		}()
		for k:=0;k<cpunum;k++{
			go func() {
				for v:= range ch{
					fmt.Println(v,"XXX")
					ShellSortStep(arr,v,gap)
				}
				wg.Done()
			}()
		}
		wg.Wait()
	}
	fmt.Println(arr)

}

插入排序

func insertsort(arr []int) []int{
	if len(arr) <= 1{
		return arr
	}
		for m :=i+1;m<len(arr);m++{
			j := m -1
			tmp :=arr[m]
			for j >= 0 && tmp < arr[j]{
				arr[j+1] = arr[j]
				j --
			}
			arr[j+1] = tmp
		}
	return arr
}

插入排序 特別像 老師在幫我們排隊時 找到一個人作爲標準 然後高於 這個人的排在右邊低於這個人的 排在左邊 如果這麼想 再細想的話 如果找一個最高 或者最低的人作爲標準 去排的話 那麼 所有其他人 都要調整位置 這樣的話 就要交換N-1次。