以前經常看到各種排序算法，今天也對以下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]}}} } 復制代碼

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]}} } 復制代碼

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]}} }復制代碼

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]}}} } 復制代碼

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

/** 快速排序 @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) } 復制代碼

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)} }復制代碼

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 // 左右兩切片的下標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 } 復制代碼

測試過程： 統計時間 = 產生隨機數時間 + 排序時間

• 產生10萬隨機數排序結果如下圖：
• 產生20萬隨機數排序結果如下圖：
• 產生1000萬隨機數排序結果如下圖：

總結：

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

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

---

轉載于:https://juejin.im/post/5b7d726fe51d4538c411d42c

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。