Go语言冒泡排序

冒泡排序的基本原理是重复地循环遍历要排序的元素列，依次比较两个相邻的元素，如果顺序（如从小到大或者首字母从 Z 到 A）错误就把两个元素的位置交换过来，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

冒泡排序的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同气泡最终会上浮到顶端一样，故名“冒泡排序”。

下面通过一个实例来演示一下冒泡排序，完整代码如下：

package main

import (
   "fmt"
)
/**
冒泡排序
*/
func main() {
    arr := [...]int{21,32,12,33,34,34,87,24}
    var n = len(arr)
    fmt.Println("--------没排序前--------/n",arr)
    for i := 0; i <= n-1; i++ {
        fmt.Println("--------第",i+1,"次冒泡--------")
        for j := i; j <= n-1; j++ {
            if arr[i] > arr[j] {
                t := arr[i]
                arr[i] = arr[j]
                arr[j] = t
            }
            fmt.Println(arr)

        }
    }
    fmt.Println("--------最终结果--------/n",arr)
}

执行结果如下所示：

D:/code>go run main.go
——–没排序前——–
[21 32 12 33 34 34 87 24]
——–第 1 次冒泡——–
[21 32 12 33 34 34 87 24]
[21 32 12 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
[12 32 21 33 34 34 87 24]
——–第 2 次冒泡——–
[12 32 21 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
——–第 3 次冒泡——–
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 32 33 34 34 87 24]
[12 21 24 33 34 34 87 32]
——–第 4 次冒泡——–
[12 21 24 33 34 34 87 32]
[12 21 24 33 34 34 87 32]
[12 21 24 33 34 34 87 32]
[12 21 24 33 34 34 87 32]
[12 21 24 32 34 34 87 33]
——–第 5 次冒泡——–
[12 21 24 32 34 34 87 33]
[12 21 24 32 34 34 87 33]
[12 21 24 32 34 34 87 33]
[12 21 24 32 33 34 87 34]
——–第 6 次冒泡——–
[12 21 24 32 33 34 87 34]
[12 21 24 32 33 34 87 34]
[12 21 24 32 33 34 87 34]
——–第 7 次冒泡——–
[12 21 24 32 33 34 87 34]
[12 21 24 32 33 34 34 87]
——–第 8 次冒泡——–
[12 21 24 32 33 34 34 87]
——–最终结果——–
[12 21 24 32 33 34 34 87]