文章目录

• go 冒泡排序 & 选择排序
  • 冒泡排序
  • 选择排序
  • 全部代码
  • 运行结果

go 冒泡排序 & 选择排序

冒泡排序

将每一个数同相邻的下一个数对比,如果比下一个数大则交换位置.

func bubble(list []int) []int {
    //用来拍断是否完成排序
    flag := true
    len := len(list)

    for i := 0; i < len-1; i++ {
        //预设没有发生交换 flag=true,当发生交换,flag=false
        flag = true
        for j := 0; j < len-1-i; j++ {
            if list[j] > list[j+1] {
                //这一轮有数据前后交换位置
                flag = false
                list[j], list[j+1] = list[j+1], list[j]
            }
        }
        if flag {
            //如果此循环没有前后交换的数,直接跳出循环
            break
        }
    }
    return list
}

选择排序

每一次从待排序的数据元素中选出最小的一个元素,存放在序列起始位置.
再从剩余的未排序元素中继续寻找最小元素,然后放在已排序的末尾,以此类推,直到全部排完

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

全部代码

package main

import (
    "fmt"
    "time"
)

/**
冒泡排序:将每一个数同相邻的下一个数对比,如果比下一个数大则交换位置.
*/
func bubble(list []int) []int {
    //用来拍断是否完成排序
    flag := true
    len := len(list)

    for i := 0; i < len-1; i++ {
        //预设没有发生交换 flag=true,当发生交换,flag=false
        flag = true
        for j := 0; j < len-1-i; j++ {
            if list[j] > list[j+1] {
                //这一轮有数据前后交换位置
                flag = false
                list[j], list[j+1] = list[j+1], list[j]
            }
        }
        if flag {
            //如果此循环没有前后交换的数,直接跳出循环
            break
        }
    }
    return list
}

/**
选择排序:
每一次从待排序的数据元素中选出最小的一个元素,存放在序列起始位置.
再从剩余的未排序元素中继续寻找最小元素,然后放在已排序的末尾,以此类推,直到全部排完
*/
func compare(list []int) []int {
    len := len(list)
    for i := 0; i < len-1; i++ {
        for j := i + 1; j < len; j++ {
            if list[i] > list[j] {
                list[j], list[i] = list[i], list[j]
            }
        }
    }
    return list
}

func main() {
    list := []int{89, 56, 8, 76, 34, 60, 11, 77, 21, 59, 61, 20, 79, 90, 65, 43, 12, 9, 201}
    fmt.Println(list)
    bT1 := time.Now() //开始时间
    fmt.Println(bubble(list))
    eT1 := time.Since(bT1) //从开始到现在所消耗的时间

    bT2 := time.Now() //开始时间
    fmt.Println(compare(list))
    eT2 := time.Since(bT2) //从开始时间到现在所消耗时间段
    
    
    fmt.Println("Run time et1", eT1, "Run time et2", eT2)

}

main 函数中用了俩个时间段来记录俩个不同排序方法运行时需要的耗时比较

运行结果

# zhangzhi @ ZhangZhi-MacBook-Pro in ~/code/go/program [22:39:16] 
$ go run main.go 
[89 56 8 76 34 60 11 77 21 59 61 20 79 90 65 43 12 9 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
Run time et1 7.76µs Run time et2 5.573µs

# zhangzhi @ ZhangZhi-MacBook-Pro in ~/code/go/program [22:40:36] 
$ go run main.go 
[89 56 8 76 34 60 11 77 21 59 61 20 79 90 65 43 12 9 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
Run time et1 6.024µs Run time et2 4.399µs

# zhangzhi @ ZhangZhi-MacBook-Pro in ~/code/go/program [22:40:47] 
$ go run main.go 
[89 56 8 76 34 60 11 77 21 59 61 20 79 90 65 43 12 9 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
Run time et1 9.471µs Run time et2 7.924µs

# zhangzhi @ ZhangZhi-MacBook-Pro in ~/code/go/program [22:40:53] 
$ go run main.go 
[89 56 8 76 34 60 11 77 21 59 61 20 79 90 65 43 12 9 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
Run time et1 9.539µs Run time et2 8.03µs

# zhangzhi @ ZhangZhi-MacBook-Pro in ~/code/go/program [22:52:35] 
$ go run main.go 
[89 56 8 76 34 60 11 77 21 59 61 20 79 90 65 43 12 9 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
[8 9 11 12 20 21 34 43 56 59 60 61 65 76 77 79 89 90 201]
Run time et1 6.015µs Run time et2 4.401µs

从上面的不严谨的测试我们大致可以感觉到, 选择排序 貌似比 第一种冒泡排序更有优势,执行耗时更短.

出自:go 语言实践:冒泡排序法