以前經(jīng)常看到各種排序算法，今天也對以下6種排序算法的時間性能做了一次測試： 測試代碼地址

1. 冒泡排序 O(n^2)

/** 冒泡排序 @Param {[]int} arr 整形切片 */ func BubbleSort(arr []int) {length := len(arr)for i := 0; i < length; i++ {for j := 0; j < length-i-1; j++ {if arr[j] > arr[j+1] {arr[j], arr[j+1] = arr[j+1], arr[j]}}} } 復(fù)制代碼

2. 插入排序 O(n^2)

/** 插入排序 @Param {[]int} arr 整形切片 */ func InsertSort(arr []int) {length := len(arr)for i := 1; i < length; i++ {for j := i; j > 0 && arr[j] < arr[j-1]; j-- {arr[j], arr[j-1] = arr[j-1], arr[j]}} } 復(fù)制代碼

3. 選擇排序 O(n^2)

/** 選擇排序 @Param {[]int} arr 整形切片 */ func SelectSort(arr []int) {length := len(arr)for i := 0; i < length-1; i++ {index := ifor j := i + 1; j < length; j++ {if arr[index] > arr[j] {index = j}}if index != i {arr[i], arr[index] = arr[index], arr[i]}} }復(fù)制代碼

4. 希爾排序 O(nlogn)

/** 希爾排序 O(nlogn) @Param {[]int} arr 整形切片 */ func ShellSort(arr []int) {length := len(arr)for fraction := length / 2; fraction > 0; fraction /= 2 {for i := fraction; i < length; i++ {for j := i - fraction; j >= 0 && arr[j] > arr[j+fraction]; j -= fraction {arr[j], arr[j+fraction] = arr[j+fraction], arr[j]}}} } 復(fù)制代碼

5. 快速排序 ：O(nlogn)期望時間，O(n^2)最壞情況；對于大的、隨機數(shù)列表一般相信是最快的已知排序

/** 快速排序 @Param {[]int} arr 整形切片 */ func QuickSort(arr []int, low, high int) {if low >= high {return}first, last := low, highkey := arr[first]for first < last {for first < last && arr[last] >= key {last--}arr[first] = arr[last]for first < last && arr[first] <= key {first++}arr[last] = arr[first]}arr[first] = keyQuickSort(arr, low, first-1)QuickSort(arr, first+1, high) } 復(fù)制代碼

6. 堆排序 O(nlogn)

/** 堆排序 O(nlogn) @Param {[]int} arr 整形切片 */ func HeapSort(arr []int) {// 切片長度length := len(arr)for i := length/2 - 1; i >= 0; i-- {Sort(arr, i, length)}for i := length - 1; i >= 0; i-- {arr[0], arr[i] = arr[i], arr[0]Sort(arr, 0, i)} }func Sort(arr []int, start, end int) {dad := startson := dad*2 + 1if son >= end {return}if son+1 < end && arr[son] < arr[son+1] {son++}if arr[son] > arr[dad] {arr[son], arr[dad] = arr[dad], arr[son]Sort(arr, son, end)} }復(fù)制代碼

7.歸并排序 O(n log n)

/** 歸并排序 O(n log n) @Param {[]int} arr 整形切片 */ func MergeSort(arr []int) []int {length := len(arr)if length <= 1 {return arr}mid := length / 2l := MergeSort(arr[:mid])r := MergeSort(arr[mid:])return Merge(l, r) }func Merge(left, right []int) (result []int) {l, r := 0, 0 // 左右兩切片的下標(biāo)for l < len(left) && r < len(right) {if left[l] < right[r] {result = append(result, left[l])l++} else {result = append(result, right[r])r++}}result = append(result, left[l:]...)result = append(result, right[r:]...)return } 復(fù)制代碼

測試過程： 統(tǒng)計時間 = 產(chǎn)生隨機數(shù)時間 + 排序時間

• 產(chǎn)生10萬隨機數(shù)排序結(jié)果如下圖：
• 產(chǎn)生20萬隨機數(shù)排序結(jié)果如下圖：
• 產(chǎn)生1000萬隨機數(shù)排序結(jié)果如下圖：

總結(jié)：

1. 在隨機數(shù)情況下，表現(xiàn)最差的是冒泡，表現(xiàn)最好的是快速排序 2. 在隨機數(shù)1000萬的時候。冒泡排序、插入排序和選擇排序排序時間未知。等了好幾分鐘都沒有結(jié)果。快速排序表現(xiàn)最好。 復(fù)制代碼

總得來說，在隨機序列的情況，快速排序表現(xiàn)最好

---

轉(zhuǎn)載于:https://juejin.im/post/5b7d726fe51d4538c411d42c

總結(jié)

以上是生活随笔為你收集整理的关于几种排序算法的时间性能比较的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。