七种常见排序的实现(Go)

冒泡排序

package main

import "fmt"

// 比较函数
func compare(a, b int) bool {
    return  a > b
}

// 冒泡排序, comp传入一个闭包, 作为是否交换值的条件判断
func BubbleSort(arr []int, comp func(a, b int) bool) []int {
    n := len(arr)
    if n <= 1 {
        return arr
    }

    for i := 0; i < n; i++ {

        flag := false // 提前退出标志位

        for j := 0; j < n - i - 1; j++ {
            if comp(arr[j], arr[j+1])  {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = true
            }
        }
        if !flag { // 如果没有数据交换，可以提前退出操作
            break
        }
    }
    return arr
}

func main() {
    arr := []int{1,5,3,2,5,7,6,113,44,-1}
    arr = BubbleSort(arr, compare)
    fmt.Println(arr)
}

插入排序

package main

import "fmt"

// 插入排序
func InsertSort(arr []int) []int {
    n := len(arr)
    if n <= 1 {
        return arr
    }

    for i := 1; i < n; i++ {
        value := arr[i]
        j := i - 1
        // 查找需要插入的位置并移动数据
        for ; j>=0; j-- { // 往左边找一个比当前value大的元素
            if arr[j] > value {
                arr[j+1] = arr[j]
            }else { // 找到了
                break
            }
        }
        arr[j+1] = value // 将元素插入找到位置中
    }
    return arr
}

func main() {
    arr := []int{1, 3, 2, 4, 7, 5,9}
    arr = InsertSort(arr)
    fmt.Println(arr)
}

选择排序

package main

import "fmt"

func SelectionSort(arr []int) []int {
    n := len(arr)
    if n <= 1 {
        return arr
    }

    for i := 0; i < n; i++ {
        minIdx := i  // 记录最小值的索引

        // 查找最小值的索引
        for j := i + 1; j < n; j++ {
            if arr[j] < arr[minIdx] {
                minIdx = j
            }
        }
        // 当前值与最小值进行交换
        arr[i], arr[minIdx] = arr[minIdx], arr[i]
    }
    return arr
}


func main() {
    arr := []int{22,44,11,13,67, -1,9,3}
    arr = SelectionSort(arr)
    fmt.Println(arr)
}

归并排序

package main

import "fmt"


// 归并排序
func MergeSort(arr []int) {
    arrLen := len(arr)
    if arrLen <= 1 {
        return
    }

    mergeSort(arr, 0, arrLen-1)
}

func mergeSort(arr []int, start, end int) {
    if start >= end {
        return
    }
    
    // 分治法将数组拆分
    mid := (start + end) / 2
    mergeSort(arr, start, mid)
    mergeSort(arr, mid+1, end)
    merge(arr, start, mid, end) // 合并数组
}

// 合并有序数组
func merge(arr []int, start, mid, end int) {
    tmpArr := make([]int, end-start+1)

    i := start 
    j := mid + 1
    k := 0
    
    // 双指针思想进行数组合并
    for ; i <= mid && j <= end; k++ {
        if arr[i] <= arr[j] {
            tmpArr[k] = arr[i]
            i++
        } else {
            tmpArr[k] = arr[j]
            j++
        }
    }

    for ; i <= mid; i++ {
        tmpArr[k] = arr[i]
        k++
    }
    for ; j <= end; j++ {
        tmpArr[k] = arr[j]
        k++
    }
    copy(arr[start:end+1], tmpArr)
}

func main()  {
    arr := []int{1,3,5,2,4,6,7}
    MergeSort(arr)
    fmt.Println(arr)
}

快速排序

package main

import "fmt"

func QuickSort(arr []int) {
    separateSort(arr, 0, len(arr)-1)
}

func separateSort(arr []int, start, end int)  {
    if start >= end {
        return
    }
    i := partition(arr, start, end)
    separateSort(arr, start, i-1)
    separateSort(arr, i+1, end)
}


func partition(arr []int, start, end int) int  {
    pivot := arr[end] // 选取最后一位当基准数据
    var i = start
    for j := start; j < end; j++ {
        if arr[j] < pivot {
            if i != j {
                arr[i], arr[j] = arr[j], arr[i]
            }
            i++
        }
    }
    arr[i], arr[end] = arr[end], arr[i]
    return i
}

func main()  {
    arr := []int{1,4,6,2,3,9,0}
    QuickSort(arr)
    fmt.Println(arr)
}

桶排序

package main

import "fmt"

// 获取待排序数组中最大值
func getMax(a []int)int {
    max := a[0]

    for i:=1; i<len(a); i++ {
        if a[i] > max {
            max = a[i]
        }
    }
    return max
}


// 桶排序
func BucketSort(source []int)  {
    if len(source) <= 1 {
        return
    }
    array := make([]int, getMax(source)+1) // 创建一个桶
    for i:=0; i<len(source);i++{ // 桶计各个桶中元素出现次数
        array[source[i]]++
    }
    c := make([]int, 0)
    for i:=0; i < len(array); i++ {
        for array[i] != 0 { // 待排序数组可能有多个相同元素， 这里要根据统计值进行添加
            c = append(c,i)
            array[i]--
        }
    }
    copy(source, c)
}

func main() {
    arr := []int{2,1, 1,1,4,3,2,3,4}
    BucketSort(arr)
    fmt.Println(arr)
}

计数排序

package main

import (
    "fmt"
    "math"
)

func CountingSort(arr []int, n int)  {
    if n <= 1 {
        return
    }

    var max int = math.MinInt32

    // 求出数组中的最大值
    for i := range arr {
        if arr[i] > max {
            max = arr[i]
        }
    }

    c := make([]int, max+1)

    for i:= range arr {
        c[arr[i]]++
    }

    for i:=1;i<=max;i++ {
        c[i] += c[i-1]
    }

    r := make([]int, n)
    for i := n - 1; i >= 0; i-- {
        idx := c[arr[i]] - 1
        r[idx] = arr[i]
        c[arr[i]]--
    }
    copy(arr, r)
}


func main() {
    arr := []int{1,3,2,4,6,8,4,6}
    CountingSort(arr, len(arr))
    fmt.Println(arr)
}