GoLang 四大经典排序(冒泡排序,选择排序,插入排序,快速排序)写法及执行效率

• 冒泡排序

　　

package main

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

//BubbleSort 冒泡排序
func BubbleSort(arr *[10]int) {
    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-1-i; j++ {
            if arr[j] > arr[j+1] {
                // t := arr[j]
                // arr[j] = arr[j+1]
                // arr[j+1] = t

                arr[j], arr[j+1] = arr[j+1], arr[j]

            }

        }
        fmt.Printf("第%v 次 排序后arr: %v
", i+1, *arr)
    }
}

//GetRandomNum 获取随机数
func GetRandomNum() [10]int {

    countNum := 0
    var num [10]int
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        r := rand.Intn(100) + 1
        num[i] = r
        countNum++
    }
    fmt.Printf("一共生成 %v 个 随机数
", countNum)
    return num
}

func main() {
    arr := GetRandomNum()

    fmt.Printf("冒泡排序前的数组:%v
", arr)
    fmt.Println()
    fmt.Println("开始排序...")
    BubbleSort(&arr)
    fmt.Println("结束排序...")
    fmt.Println()
    fmt.Printf("冒泡排序后的数组:%v
", arr)
}

• 选择排序

• 

package main

import "fmt"

//SelectSort 选择排序
func SelectSort(arr *[10]int) {
    for j := 0; j < len(arr)-1; j++ {
        max := arr[j]
        maxIndex := j
        for i := j + 1; i < len(arr); i++ {
            if max < arr[i] {
                //记录
                max = arr[i]
                maxIndex = i
            }
        }
        //交换
        if maxIndex != j {
            arr[j], arr[maxIndex] = arr[maxIndex], arr[j]
        }
        fmt.Printf("数据第 %v 次交换后为:	%v
", j+1, *arr)
    }
}

func main() {
    arr := [10]int{10, 9, 15, 55, 67, 77, 25, 350, 99, 100}
    fmt.Printf("排序前数组:		%v
", arr)
    fmt.Println()
    SelectSort(&arr)
    fmt.Println()
    fmt.Printf("排序后数组:		%v
", arr)

}

• 插入排序
• 

package main

import "fmt"

//InsertSort 插入排序
func InsertSort(arr *[10]int) {
    for i := 1; i < len(arr); i++ {
        insertVal := arr[i]
        insertIndex := i - 1

        /* 从大到小 */
        for insertIndex >= 0 && arr[insertIndex] < insertVal {
            //数据后移
            arr[insertIndex+1] = arr[insertIndex]
            insertIndex--
        }
        /* 插入数据 */
        if insertIndex+1 != i {
            arr[insertIndex+1] = insertVal
        }

        fmt.Printf("第 %v 次插入数据后:	%v
", i, *arr)
    }
}

func main() {

    arr := [10]int{10, 9, 15, 55, 67, 77, 25, 350, 99, 100}
    fmt.Printf("原数据:			%v
", arr)
    fmt.Println()
    InsertSort(&arr)
    fmt.Println()
    fmt.Printf("插入排序后:		%v
", arr)
}

• 快速排序(递归算法) 

package main

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

//GetRandomNum 获取随机数
func GetRandomNum() [66]int {

    countNum := 0
    var num [66]int
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 66; i++ {
        r := rand.Intn(1000) + 1
        num[i] = r
        countNum++
    }
    fmt.Printf("一共生成 %v 个 随机数
", countNum)
    return num
}

//QuickSort 快速排序
func QuickSort(left int, right int, array *[66]int) {

    l := left                       //数组左边数据下标
    r := right                      //数组右边数据下标
    center := array[(left+right)/2] //数组中间数据下标
    t := 0                          //临时变量
    for l < r {
        /* 可改变< > 若l > r 就改 < ,否则反之*/
        for array[l] < center {
            l++
        }

        /* 可改变< > */
        for array[r] > center {
            r--
        }
        if l >= r {
            break
        }
        t = array[l]
        array[l] = array[r]
        array[r] = t
        if array[l] == center {
            r--
        }
        if array[r] == center {
            l++
        }
    }

    /* 不加这个判断,就成死循环,无限递归 */
    if l == r {
        l++
        r--
    }

    /* 向左递归 */
    if left < r {
        QuickSort(left, r, array)
    }
    /* 向右递归 */
    if right > l {
        QuickSort(l, right, array)
    }
}
func main() {
    start := time.Now().Unix()
    end := time.Now().Unix()

    fmt.Println("开始排序...")
    num := GetRandomNum()
    //fmt.Println("排序前数组:", num)
    fmt.Println()
    QuickSort(0, len(num)-1, &num)
    fmt.Println()
    for i := 0; i < len(num); i++ {
        fmt.Printf("排序后数组:	%v						
", num[i])
    }

    fmt.Println("结束排序...")
    fmt.Printf("快速排序计算66个数字一共耗时 %v 秒", end-start)
}

• 速度测试:

• [ 注:统计时间根据电脑硬件配置不同,结果会有差异 ]

• 创建一个获取随机数函数,生成100W个(1-1000)的随机数,

• 分别让冒泡排序,选择排序,插入排序,快速排序 进行排序,并统计消耗时间

//GetRandomNum 获取随机数
func GetRandomNum() [1000000]int {

    countNum := 0
    var num [1000000]int
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 1000000; i++ {
        r := rand.Intn(1000) + 1
        num[i] = r
        countNum++
    }
    fmt.Printf("一共生成 %v 个 随机数
", countNum)
    return num
}

• 耗时统计结果:
• 冒泡排序(100W个随机数)
• 

   

• 选择排序(100W个随机数)
• 

• 插入排序  (100W个随机数)
• 

• 快速排序(由于速度太快,故将数据提升至5000W)
• 
• 测试结果(执行效率从快到慢) :
• 快速排序  >  插入排序  > 选择排序  >  冒泡排序