码迷,mamicode.com
首页 > 编程语言 > 详细

Golang常用排序算法比较

时间:2021-06-28 18:47:49      阅读:0      评论:0      收藏:0      [点我收藏+]

标签:false   rate   span   时间   复制   打印   i++   imp   交换   

使用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
}

1.冒泡排序

/*
冒泡排序(排序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
}

执行结果:

技术图片

2.选择排序

/*
选择排序(排序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]
    }
}

执行结果:

技术图片

3.快速排序

/*
快速排序(排序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
}

执行结果:

技术图片

4.插入排序

/*
插入排序(排序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
        }
    }
}

执行结果:

技术图片

 

Golang常用排序算法比较

标签:false   rate   span   时间   复制   打印   i++   imp   交换   

原文地址:https://www.cnblogs.com/qingfj/p/14934551.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!