代码实例（未优化）：

package main

import "fmt"

func main() {
    // 打乱的数据源
    arr := []int{3, 6, 4, 2, 11, 10, 5}

    // 冒泡排序
    arr = bubbleSort(arr)

    // 输出数据
    fmt.Println(arr)
}

// 冒泡排序
func bubbleSort(arr []int) []int {
    len := len(arr)
    for i := 0; i < len-1; i++ {
        for j := 0; j < len-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
    return arr
}

代码实例（优化一）：

• 在全部数据中，前面数比后面数大，就会发生交换，把大的数换到后面去
• 因此可以加一个标记，当有一趟排序没任何交换，说明数据已经排序好了
• 此时就可以中断循环，不必再比较了

// 冒泡排序
func bubbleSort(arr []int) []int {
    len := len(arr)
    flag := false
    for i := 0; i < len-1; i++ {
        flag = true
        for j := 0; j < len-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = false
            }
        }
        if flag {
            return arr
        }
    }
    return arr
}

代码实例（优化二）：

• 第一次外循环会把最大值交换到最后一个位置
• 第二次外循环会把次大的值交换到倒数第二位
• 以此类推，随着一次次的循环，后面的部分都已经是有序的了
• 那么，靠后部分就不必在进行比较（即：每次内循环的次数 -1 = 减去外循环的当前次数）

// 冒泡排序
func bubbleSort(arr []int) []int {
    len := len(arr)
    flag := false
    for i := 0; i < len-1; i++ {
        flag = true
        for j := 0; j < len-1-i; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = false
            }
        }
        if flag {
            return arr
        }
    }
    return arr
}

代码实例（优化三）：

• 在优化二中，每次循环都只找出了最大值，并且放到了最后的位置
• 如果循环既寻找最大值和最小值，并把最大值放到最后、最小值放到最前
• 就可以进一步优化了

// 冒泡排序
func bubbleSort(arr []int) []int {
    len := len(arr)
    l_borden := 0       // 左边界初始值
    r_borden := len - 1 // 右边界初始值
    l_pos := 0          // 记录左边界的值
    r_pos := 0          // 记录右边界的值
    flag := false
    for i := 0; i < len-1; i++ {
        flag = true
        // 正向找出最大值
        for j := l_borden; j < r_borden; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
                flag = false
                r_pos = j
            }
        }
        if flag {
            return arr
        }
        // 逆向找出最小值
        for j := r_borden; j > l_borden; j-- {
            if arr[j] < arr[j-1] {
                arr[j], arr[j-1] = arr[j-1], arr[j]
                flag = false
                l_pos = j
            }
        }
        if flag {
            return arr
        }
        r_borden = r_pos
        l_borden = l_pos
    }
    return arr
}