Golang 函数：算法选择如何影响函数性能？

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

func quickSort(numbers []int) {
    if len(numbers) <= 1 {
        return
    }

    pivot := numbers[len(numbers)-1]
    left := make([]int, 0)
    right := make([]int, 0)

    for i := 0; i < len(numbers)-1; i++ {
        if numbers[i] < pivot {
            left = append(left, numbers[i])
        } else {
            right = append(right, numbers[i])
        }
    }

    quickSort(left)
    quickSort(right)

    copy(numbers, append(left, pivot, right...))
}

func mergeSort(numbers []int) []int {
    if len(numbers) <= 1 {
        return numbers
    }

    mid := len(numbers) / 2
    left := mergeSort(numbers[:mid])
    right := mergeSort(numbers[mid:])

    return merge(left, right)
}

func merge(left, right []int) []int {
    merged := make([]int, 0)

    leftIndex := 0
    rightIndex := 0

    for leftIndex < len(left) || rightIndex < len(right) {
        if leftIndex < len(left) && rightIndex < len(right) {
            if left[leftIndex] < right[rightIndex] {
                merged = append(merged, left[leftIndex])
                leftIndex++
            } else {
                merged = append(merged, right[rightIndex])
                rightIndex++
            }
        } else if leftIndex < len(left) {
            merged = append(merged, left[leftIndex])
            leftIndex++
        } else if rightIndex < len(right) {
            merged = append(merged, right[rightIndex])
            rightIndex++
        }
    }

    return merged
}

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    const listSize = 100000

    // 生成随机整数列表
    numbers := make([]int, listSize)
    for i := range numbers {
        numbers[i] = rand.Intn(listSize)
    }

    // 对列表进行排序并记录耗时
    startTime := time.Now()
    bubbleSort(numbers)
    fmt.Println("冒泡排序耗时：", time.Since(startTime))

    startTime = time.Now()
    quickSort(numbers)
    fmt.Println("快速排序耗时：", time.Since(startTime))

    startTime = time.Now()
    mergeSort(numbers)
    fmt.Println("归并排序耗时：", time.Since(startTime))
}

冒泡排序耗时： 1.031054592s
快速排序耗时： 0.012566785s
归并排序耗时： 0.008079981s