leetcode-排序-常见排序算法

冒泡排序

func BubbleSort(arr []int) {
    n := len(arr)
    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] // 交换
            }
        }
    }
}

选择排序

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] // 交换
    }
}

插入排序

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 quickSort(arr []int) []int {
   if len(arr) <= 1 {
      return arr
   }

   var left, right []int
   pivot := arr[0]
   for _, v := range arr[1:] {
      if v < pivot {
         left = append(left, v)
      } else {
         right = append(right, v)
      }
   }

   left = quickSort(left)
   right = quickSort(right)
   return append(append(left, pivot), right...)
}

归并排序

func MergeSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }
    mid := len(arr) / 2
    left := MergeSort(arr[:mid]) // 递归排序左半部分
    right := MergeSort(arr[mid:]) // 递归排序右半部分
    return merge(left, right) // 合并两个有序数组
}

func merge(left, right []int) []int {
    result := []int{}
    i, j := 0, 0
    for i < len(left) && j < len(right) {
        if left[i] < right[j] {
            result = append(result, left[i])
            i++
        } else {
            result = append(result, right[j])
            j++
        }
    }
    result = append(result, left[i:]...) // 添加剩余元素
    result = append(result, right[j:]...)
    return result
}

时间复杂度和空间复杂度汇总

排序算法	最好情况时间复杂度	最坏情况时间复杂度	平均情况时间复杂度	空间复杂度
冒泡排序	O(n)	O(n²)	O(n²)	O(1)
选择排序	O(n²)	O(n²)	O(n²)	O(1)
插入排序	O(n)	O(n²)	O(n²)	O(1)
快速排序	O(n log n)	O(n²)	O(n log n)	O(log n) ~ O(n)
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)