使用Go语言写的冒泡排序（4种写法）

package main

import(
    "fmt"
)

//用于计数排序中访问了多少次序列
var cnt int= 0


//最原始的冒泡排序
func buble_sort(a []int){
    cnt = 0
    for i := 0; i < len(a)-1; i++ {
        for j := 0; j < len(a)-1-i; j++{//相邻元素两两比较
            if (a[j] > a[j+1]) {
                a[j], a[j+1] = a[j+1], a[j]
            }
        }
        cnt++//每完成一次内循环就访问了一次序列
    }
}

//增加标志判断是否发生交换，如果没有发生交换，表明序列有序，结束比较，直接退出
func flag_sort(a []int){
    flag := true//默认序列有序
    cnt = 0
    for i := 0; i < len(a)-1; i++ {
        flag = true//每次访问待排序序列之初默认序列有序
        for j := 0; j < len(a)-1-i; j++{
            if (a[j] > a[j+1]) {
                a[j], a[j+1] = a[j+1], a[j]
                flag = false//发生交换--表明序列无序--需要进行下一次比较
            }
        }
        cnt++//每完成一次内循环就访问了一次序列
        if flag {//如果此次序列访问没有发生交换--表明序列有序--结束排序，避免多余的遍历
            break
        }

    }
}


//除了标志位以外，记录最后一次发生交换的下标，更能减少不必要的比较
func better_sort(a []int){
    flag := true
    k := len(a)-1//控制内部比较循环  
    n := 0//记录最后一次发生交换的下标
    cnt = 0
    for i := 0; i < len(a)-1; i++ {
        flag = true//每次访问待排序序列之初默认序列有序
        n = 0//每次访问待排序序列之初默认序列有序，没有发生交换，最后交换的下标就是0
        for j := 0; j < k; j++{
            if (a[j] > a[j+1]) {
                a[j], a[j+1] = a[j+1], a[j]
                flag = false
                n = j//保存最后一次交换的下标
            }
        }
        cnt++
        if flag {//如果这趟走完，没有发生交换，则原数组有序
            break
        }
        k = n//最后一次交换的位置给k，减少比较的次数
    }
}

//鸡尾酒冒泡排序--先从低到高，再从高到低--分为两大步骤，结合标志判断
func cocktail_sort(a []int) {
    left := 0
    right := len(a) - 1
    cnt = 0
    flag := true
    for(left < right){
        flag = true
        for i :=left; i < right; i++{// 前半轮,将最大元素放到后面
            if (a[i] > a[i+1]) {
                a[i], a[i+1] = a[i+1], a[i]
                flag = false
            }
        } 
        cnt++
        right--
        if flag {//如果此次序列访问没有发生交换--表明序列有序--结束排序，避免多余的遍历
            break
        }

        for i :=right; i > left; i--{// 后半轮,将最小元素放到前面
            if (a[i] < a[i-1]) {
                a[i], a[i-1] = a[i-1], a[i]
                flag = false
            }
        } 
        cnt++
        left++
        if flag {//如果此次序列访问没有发生交换--表明序列有序--结束排序，避免多余的遍历
            break
        }

    }
}





func main(){
    b := [...]int{8,7,6,1,4,3,2,5}
    buble_sort(b[:])
    fmt.Println(b,cnt)

    c := []int{2,3,4,5,6,1}
    cocktail_sort(c)
    fmt.Println(c,cnt)

    d := []int{8,7,6,1,4,3,2,5}
    flag_sort(d)
    fmt.Println(d,cnt)

    e := []int{2,3,4,5,6,1}
    better_sort(e)
    fmt.Println(e,cnt)
}