常见排序算法及golang实现

2024-02-07 07:00:22

了解排序算法对于任何程序员来说都是至关重要的，它不仅可以提高程序效率，同时还能提升程序的代码质量。
本文将介绍五种最常用的排序算法，并使用Go语言实现它们，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。我们不仅将给出这些算法的Go语言实现，还将对它们的优缺点进行分析比较。

冒泡排序

冒泡排序（Bubble Sort）是一种最简单的排序算法之一。它的工作原理是：比较相邻的两个元素，如果第一个比第二个大，就交换它们两个；对每一对相邻的元素作同样的工作，从开始的第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；然后再从头到尾重复这个过程，直到没有更多的元素需要交换。

Go语言实现：

func bubbleSort(arr []int) {
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr)-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

选择排序

选择排序（Selection Sort）的工作原理是：找到数组中最小的元素，然后将其与第一个元素交换；然后找到数组中第二小的元素，将其与第二个元素交换；以此类推，直到数组中的所有元素都被排序。

Go语言实现：

func selectionSort(arr []int) {
    for i := 0; i < len(arr); i++ {
        minIndex := i
        for j := i + 1; j < len(arr); j++ {
            if arr[j] < arr[minIndex] {
                minIndex = j
            }
        }
        arr[i], arr[minIndex] = arr[minIndex], arr[i]
    }
}

插入排序

插入排序（Insertion Sort）的工作原理是：将数组中的第一个元素视为一个有序的子数组，然后将第二个元素插入到有序子数组中，使得有序子数组仍然有序；然后将第三个元素插入到有序子数组中，以此类推，直到数组中的所有元素都被排序。

Go语言实现：

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

快速排序

快速排序（Quick Sort）的工作原理是：选择数组中的一个元素作为枢轴元素，然后将数组中的所有元素分为两部分，一部分是比枢轴元素小的元素，另一部分是比枢轴元素大的元素；然后递归地对这两个部分进行排序。

Go语言实现：

func quickSort(arr []int, low int, high int) {
    if low < high {
        pivot := partition(arr, low, high)
        quickSort(arr, low, pivot-1)
        quickSort(arr, pivot+1, high)
    }
}

func partition(arr []int, low int, high int) int {
    pivot := arr[high]
    i := low - 1
    for j := low; j < high; j++ {
        if arr[j] < pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

归并排序

归并排序（Merge Sort）的工作原理是：将数组分成两部分，然后递归地对这两部分进行排序，最后将这两部分合并成一个有序的数组。

Go语言实现：

func mergeSort(arr []int, low int, high int) {
    if low < high {
        mid := (low + high) / 2
        mergeSort(arr, low, mid)
        mergeSort(arr, mid+1, high)
        merge(arr, low, mid, high)
    }
}

func merge(arr []int, low int, mid int, high int) {
    temp := make([]int, high-low+1)
    i := low
    j := mid + 1
    k := 0

    for i <= mid && j <= high {
        if arr[i] < arr[j] {
            temp[k] = arr[i]
            i++
        } else {
            temp[k] = arr[j]
            j++
        }
        k++
    }

    for i <= mid {
        temp[k] = arr[i]
        i++
        k++
    }

    for j <= high {
        temp[k] = arr[j]
        j++
        k++
    }

    for i := low; i <= high; i++ {
        arr[i] = temp[i-low]
    }
}

优缺点比较

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(1)	不稳定
插入排序	O(n^2)	O(1)	稳定
快速排序	O(n log n)	O(log n)	不稳定
归并排序	O(n log n)	O(n)	稳定