代码实例（未优化）：
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
}
