go语言实现排序算法 | 青训营笔记

99 阅读2分钟

各排序算法的性能分析

  1. 插入排序

    • 时间复杂度:最好情况下为 O(n),最坏情况下为 O(n^2),平均情况下为 O(n^2)。
    • 空间复杂度:O(1)。
    • 稳定性:稳定。
  2. 希尔排序

    • 时间复杂度:最好情况下为 O(n),最坏情况下为 O(n^2),平均情况下为 O(nlogn) 或 O(n^(3/2)),具体取决于间隔序列的选择。
    • 空间复杂度:O(1)。
    • 稳定性:不稳定。
  3. 选择排序

    • 时间复杂度:最好情况下为 O(n^2),最坏情况下为 O(n^2),平均情况下为 O(n^2)。
    • 空间复杂度:O(1)。
    • 稳定性:不稳定。
  4. 堆排序

    • 时间复杂度:最好情况下为 O(nlogn),最坏情况下为 O(nlogn),平均情况下为 O(nlogn)。
    • 空间复杂度:O(1)。
    • 稳定性:不稳定。
  5. 冒泡排序

    • 时间复杂度:最好情况下为 O(n),最坏情况下为 O(n^2),平均情况下为 O(n^2)。
    • 空间复杂度:O(1)。
    • 稳定性:稳定。
  6. 快速排序

    • 时间复杂度:最好情况下为 O(nlogn),最坏情况下为 O(n^2),平均情况下为 O(nlogn)。
    • 空间复杂度:最好情况下为 O(logn),最坏情况下为 O(n),平均情况下为 O(logn)。
    • 稳定性:不稳定。
  7. 归并排序

    • 时间复杂度:最好情况下为 O(nlogn),最坏情况下为 O(nlogn),平均情况下为 O(nlogn)。
    • 空间复杂度:最好情况下为 O(n),最坏情况下为 O(n),平均情况下为 O(n)。
    • 稳定性:稳定。

插入排序

直接插入排序

每次从后面拿未排序的数字,放入到前面已经排好序的合适位置。

func insertionSort(arr []int) {  
    n := len(arr)
    for i := 1; i < n; i++ {  
        key := arr[i] 
        j := i - 1 
        for j >= 0 && arr[j] > key {  
            arr[j+1] = arr[j] 
            j-- 
        }  
        arr[j+1] = key 
    }  
}

希尔排序

希尔排序是基于插入排序的一种改进版本,又称缩小增量法

代码实现:

func shellSort(arr []int) {  
    n := len(arr)  
    gap := n / 2  
    for gap > 0 {  
        for i := gap; i < n; i++ {  
            key := arr[i]  
            j := i - gap  
            for j >= 0 && arr[j] > key {  
                arr[j+gap] = arr[j]  
                j -= gap  
            }  
            arr[j+gap] = key  
        }  
    gap /= 2  
    }  
}