用 Go 语言实现常见的十大排序算法(上)

十大常见的排序算法有:

  • 冒泡排序(Bubble Sort)

  • 选择排序(Selection Sort)

  • 插入排序(Insertion Sort)

  • 希尔排序(Shell Sort)

  • 归并排序(Merge Sort)

  • 桶排序(Bucket Sort)

  • 快速排序(Quick Sort)

  • 堆排序(Heap Sort)

  • 计数排序(Counting Sort)

  • 基数排序(Radix Sort)

一个一个说

冒泡排序

冒泡排序是一种简单的排序算法,通过重复比较相邻元素并交换位置从而确定一个元素的位置,直到没有需要交换的元素

大体有两种写法,一种是从前往后比,每次确定一个较大值;一种是从后往前比,每次确定一个较小值

复制代码
 func BubbleSort(arr []int) {
     n := len(arr)
 ​
     // 1、每次确定一个较大值的位置
     for i := 0; i < n-1; i++ {
         for j := 0; j < n-i-1; j++ {
             if arr[j] > arr[j+1] {
                 // 如果当前值大于下一位,就交换
                 arr[j], arr[j+1] = arr[j+1], arr[j]
             }
         }
     }
 ​
     // 2、每次确定一个较小值的位置
     for i := 0; i < n-1; i++ {
         for j := n - 1; j > i; j-- {
             if arr[j] < arr[j-1] {
                 // 当前值小于上一位,就交换
                 arr[j], arr[j-1] = arr[j-1], arr[j]
             }
         }
     }
 ​
     return arr
 }

冒泡排序是稳定的,稳定是指相同元素在排序完后相对位置不变,例如切片[2, 1, 3, 1, 5],经过排序后第一个 "1" 还是在第二个 "1" 之前

冒泡排序的平均时间复杂度是O(n^2),在元素近似有序的情况下,会有很多没有必要的比较和交换,一种优化思路是使用标志位,如果一次循环没有发生任何元素交换,就表示切片已经有序了,直接退出就可以,不需要再往下比较,这在元素近似有序的情况下会很省时间

复制代码
 func BubbleSort(arr []int) {
     n := len(arr)
 ​
     // 使用标志位和缩小比较范围优化
     for i := 0; i < n-1; i++ {
         swapped := false // 标志位,记录这次外层循环中是否有过交换
 ​
         for j := 0; j < n-i-1; j++ {
             if arr[j] > arr[j+1] {
                 arr[j], arr[j+1] = arr[j+1], arr[j]
                 swapped = true
             }
         }
 ​
         // 如果一次交换都没有,说明数组已经有序了,没有必要再循环下去
         if !swapped {
             break
         }
 ​
     }
 ​
     return arr
 }

选择排序

选择排序的思路是,反复选择未排序部分的最小(大)元素,把它放到已排序部分的末尾

复制代码
 func selectionSort(arr []int) {
     n := len(arr)
 ​
     for i := 0; i < n-1; i++ {
         // 最小元素下标
         minIndex := i
         for j := i + 1; j < n; j++ {
             // 找出待排序元素中最小的一个
             if arr[j] < arr[minIndex] {
                 minIndex = j
             }
         }
         // 把找出来的最小元素放到排序好的元素末尾
         arr[i], arr[minIndex] = arr[minIndex], arr[i]
     }
 ​
     return arr
 }

特点:时间复杂度是 O(n^2)、不稳定的(比如待排序元素为 [5, 5, 3],把 3 和 5 交换就完成了排序,但是原先在之前的 5 变成了后面)、没有明显的优化思路,

插入排序

插入排序的大概思路是,构建一个排序好的数据,把新的元素插入到适当的位置中去

复制代码
 func insertionSort(arr []int) {
     n := len(arr)
 ​
     for i := 1; i < n; i++ {
         // 待排序元素
         compare := arr[i]
         // 排序好的元素右边界值,因为 arr[i] 是待比较元素,所以 [0,i-1] 这一段数据是已经排好序的
         j := i - 1
         // 如果元素大于待排序元素就往右挪 腾出位置
         for j >= 0 && arr[j] > compare {
             arr[j+1] = arr[j]
             j--
         }
         // 把元素放到合适的位置
         arr[j+1] = compare
     }
 }

特点:时间复杂度为 O(n^2)、稳定,适合在元素基本有序时使用,有序时只需要少量判断就可以确定正确的位置

归并排序

归并排序是一种分治算法,把数组逐次对半分,分别对两半进行排序,然后把排序好的两半合并在一起

复制代码
 // 递归地拆分数组并进行归并
 func mergeSort(arr []int, l, r int) {
     // l == r 时退出 因为此时只有一个元素
     if l < r {
         // 求中间值
         m := (r-l)/2 + l
         // 递归左半边
         mergeSort(arr, l, m)
         // 递归右半边
         mergeSort(arr, m+1, r)
         // 把排好序地两半合并
         merge(arr, l, m, r)
     }
 }
 ​
 // 把两个已经排好序的子数组合并成一个有序数组
 func merge(arr []int, l, m, r int) {
     // 创建切片存放左右两半元素
     leftSize := m - l + 1 // 把中间值归左半边
     rightSize := r - m
     leftArr := make([]int, leftSize)
     rightArr := make([]int, rightSize)
 ​
     // 复制元素 注意是左开右闭区间
     copy(leftArr, arr[l:m+1])
     copy(rightArr, arr[m+1:r+1])
 ​
     // 遍历左右半边元素 挑出小的写回到待排序数组中
     i, j, k := 0, 0, l
     for i < leftSize && j < rightSize {
         if leftArr[i] <= rightArr[j] {
             arr[k] = leftArr[i]
             i++
         } else {
             arr[k] = rightArr[j]
             j++
         }
         k++
     }
 ​
     // 复制剩余元素 不处理两半不均等时会漏元素
     for i < leftSize {
         arr[k] = leftArr[i]
         i++
         k++
     }
 ​
     for j < rightSize {
         arr[k] = rightArr[j]
         j++
         k++
     }
 }

单看代码有点难理解,用一个例子来看排序的整个过程

比如现在有切片 arr = [2, 3, 1, 5]

通过 mergeSort(arr, 0, len(arr) - 1) 排序,整个流程为:

看图示流程就会比较清晰,先把左半边元素拆到底,逐个合并,使左半边元素有序,再处理右半边,把右半边也处理完,再合并左右半边,最终排序完成

特点:时间复杂度为 O(n log n)、稳定

改进思路:在元素量较小的时候,比如 10 或 20 个元素,使用插入排序比双指针要稍快一点,可以在排序过程中增加一个阈值,当子切片的长度小于该值时,使用插入排序

桶排序

大概思路是生成一些桶,把元素分布到不同的桶中,对每个桶再单独进行排序(可以使用任何排序方法,选择排序、插入排序等等),再将元素依次取出,需要注意,后一个桶中的每一个元素都要大于前一个桶中所有数据

核心点有两个:怎么确定桶的个数?哪个元素放哪个桶如何确定,即桶的索引如何确定?

对于第一个问题,桶排序适用的场景是分布均匀的浮点数,因为浮点数计算桶的索引方便一点,如果分布不均匀,可能会造成某些桶包含大量元素,某些桶只包含很少的元素,导致算法效率降低,一般来说,根据元素个数 n,桶的个数一般在 n^1/2 - n 之间

第二个问题,桶的索引计算一般基于最小值和最大值来完成,一个简单的索引计算方法:

复制代码
 index := int((value - minValue) / (maxValue - minValue) * float64(bucketCount))
  • value: 当前要处理的元素

  • minValue: 在整个数组中的最小值

  • maxValue: 在整个数组中的最大值

  • bucketCount: 总的桶的数量

简单解释这条公式,(value - minValue) / (maxValue - minValue) 意思是当前值减去最小值并除以范围(最大值和最小值的差值),把元素的值定位到 [0, 1] 的范围中,这样就可以获得元素相对于整个数据的位置,拿这个值乘以桶的总数,然后用 int() 转换为 int 类型作为桶的下标索引,这样就完成了简单的定位操作

完整代码:

复制代码
 func bucketSort(arr []float64, bucketCount int) []float64 {
     if len(arr) == 0 {
         return arr
     }
 ​
     // 找最大值和最小值
     minValue, maxValue := arr[0], arr[0]
     for _, value := range arr {
         if value < minValue {
             minValue = value
         }
         if value > maxValue {
             maxValue = value
         }
     }
 ​
     // 初始化桶 用切片表示
     buckets := make([][]float64, bucketCount)
 ​
     // 把元素分配到桶里
     for _, value := range arr {
         // 用公式计算桶的索引
         index := int((value - minValue) / (maxValue - minValue) * float64(bucketCount))
         // 如果计算出的索引越界了 手动减一
         if index >= bucketCount {
             index = bucketCount - 1
         }
         // 把元素追加到对应的桶里
         buckets[index] = append(buckets[index], value)
     }
 ​
     //  对每个桶进行排序 用哪种排序方法都可以 这里用自带的排序函数
     sortedArr := make([]float64, 0)
     for _, bucket := range buckets {
         sort.Float64s(bucket)
         sortedArr = append(sortedArr, bucket...)
     }
 ​
     return sortedArr
 }

总结

为避免篇幅过长,简单的介绍了前五种排序算法,总结如下:

参考:

1.0 十大经典排序算法 | 菜鸟教程 (runoob.com)

相关推荐
烦躁的大鼻嘎2 分钟前
模拟算法实例讲解:从理论到实践的编程之旅
数据结构·c++·算法·leetcode
C++忠实粉丝19 分钟前
计算机网络socket编程(4)_TCP socket API 详解
网络·数据结构·c++·网络协议·tcp/ip·计算机网络·算法
用户37791362947551 小时前
【循环神经网络】只会Python,也能让AI写出周杰伦风格的歌词
人工智能·算法
福大大架构师每日一题1 小时前
文心一言 VS 讯飞星火 VS chatgpt (396)-- 算法导论25.2 1题
算法·文心一言
EterNity_TiMe_1 小时前
【论文复现】(CLIP)文本也能和图像配对
python·学习·算法·性能优化·数据分析·clip
ifanatic1 小时前
[面试]-golang基础面试题总结
面试·职场和发展·golang
机器学习之心1 小时前
一区北方苍鹰算法优化+创新改进Transformer!NGO-Transformer-LSTM多变量回归预测
算法·lstm·transformer·北方苍鹰算法优化·多变量回归预测·ngo-transformer
懒是一种态度1 小时前
Golang 调用 mongodb 的函数
数据库·mongodb·golang
yyt_cdeyyds1 小时前
FIFO和LRU算法实现操作系统中主存管理
算法
XINGTECODE2 小时前
海盗王集成网关和商城服务端功能golang版
开发语言·后端·golang