Golang常用排序算法比较

package main

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

const (
    num      = 10000  // 测试数组的长度
    rangeNum = 100000 // 数组元素大小范围
)

func main() {
    arr := GenerateRand() //生成随机数组
    //排序前 复制原数组
    orgArr := make([]int, num)
    copy(orgArr, arr)

    start := time.Now() // 获取当前时间
    //bubbleSort(arr)  //冒 泡
    //selectSort(arr) //选择
    //quickSort(arr) //快速
    insertSort(arr) //插入排序
    elapsed := time.Since(start)
    fmt.Println("该函数执行完成耗时：", elapsed)
    fmt.Println(arr)

    sort.Ints(orgArr) //使sort模块对原数组排序
    //fmt.Println(arr, org_arr, IsSame(arr, org_arr))
    //打印前10个数,并对比排序是否正确
    fmt.Println(arr[:10], orgArr[:10], IsSame(arr, orgArr))
}

//生成随机数组
func GenerateRand() []int {
    randSeed := rand.New(rand.NewSource(time.Now().Unix() + time.Now().UnixNano()))
    arr := make([]int, num)
    for i := 0; i < num; i++ {
        arr[i] = randSeed.Intn(rangeNum)
    }
    return arr
}

//比较两个切片
func IsSame(slice1, slice2 []int) bool {
    if len(slice1) != len(slice2) {
        return false
    }

    if (slice1 == nil) != (slice2 == nil) {
        return false
    }

    for i, num := range slice1 {
        if num != slice2[i] {
            return false
        }
    }
    return true
}

/*
冒泡排序（排序10000个随机整数，用时约117ms）
冒泡排序的原理是，对给定的数组进行多次遍历，每次均比较相邻的两个数，如果前一个比后一个大，则交换这两个数。
经过第一次遍历之后，最大的数就在最右侧了；第二次遍历之后，第二大的数就在右数第二个位置了；以此类推。
*/
func bubbleSort(nums []int) []int {
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i] > nums[j] {
                //交换
                nums[i], nums[j] = nums[j], nums[i]
            }
        }
    }
    //os.Exit(1)
    return nums
}

/*
选择排序（排序10000个随机整数，用时约52ms）
选择排序的原理是，对给定的数组进行多次遍历，每次均找出最大的一个值的索引
*/
func selectSort(nums []int) {
    length := len(nums)
    for i := 0; i < length; i++ {
        maxIndex := 0
        //寻找最大的一个数，保存索引值
        for j := 1; j < length-i; j++ {
            if nums[j] > nums[maxIndex] {
                maxIndex = j
            }
        }
        nums[length-i-1], nums[maxIndex] = nums[maxIndex], nums[length-i-1]
    }
}

/*
快速排序（排序10000个随机整数，用时约0.6ms）[1ms=1000μs 1毫秒等于1000微妙]
快速排序的原理是，首先找到一个数pivot把数组‘平均‘分成两组，使其中一组的所有数字均大于另一组中的数字，
此时pivot在数组中的位置就是它正确的位置。然后，对这两组数组再次进行这种操作。
*/
func quickSort(nums []int) {
    recursionSort(nums, 0, len(nums)-1)
}

func recursionSort(nums []int, left int, right int) {
    if left < right {
        pivot := partition(nums, left, right)
        recursionSort(nums, left, pivot-1)
        recursionSort(nums, pivot+1, right)
    }
}

func partition(nums []int, left int, right int) int {
    for left < right {
        for left < right && nums[left] <= nums[right] {
            right--
        }
        if left < right {
            nums[left], nums[right] = nums[right], nums[left]
            left++
        }

        for left < right && nums[left] <= nums[right] {
            left++
        }
        if left < right {
            nums[left], nums[right] = nums[right], nums[left]
            right--
        }
    }
    return left
}

/*
插入排序（排序10000个整数，用时约13ms）
插入排序的原理是，从第二个数开始向右侧遍历，每次均把该位置的元素移动至左侧，放在放在一个正确的位置（比左侧大，比右侧小）。
*/
func insertSort(nums []int) {
    for i := 1; i < len(nums); i++ {
        if nums[i] < nums[i-1] {
            j := i - 1
            temp := nums[i]
            for j >= 0 && nums[j] > temp {
                nums[j+1] = nums[j]
                j--
            }
            nums[j+1] = temp
        }
    }
}