排序算法：冒泡排序

排序算法：冒泡排序

冒泡排序是一种简单的交换排序的算法，它通过交换相邻的两个数据元素，逐步将待排序序列变成有序序列。

1. 冒泡排序

1.1. 简介

从左往右将相邻的两个元素进行比较，如果第1个元素大于第2个元素，交换两个元素的位置。这样比较下去每轮最右边都是当前最大的元素，然后去除已找出来的最大元素，在剩余元素中继续找最大元素一直重置下去。

1.2. 图示

1.3. 演示

1.3.1. 文件树形图

bubblesort
├── bubble_sort.go
├── bubble_sort_test.go
└── go.mod

1.3.2. 代码

bubble_sort.go

package bubblesort

// 冒泡排序
func BubbleSort(arr []int) {
	flag := true // 如果没有发生交换停止冒泡
	for i := 0; i < len(arr)-1 && flag; i++ {
		flag = false
		for j := 0; j < len(arr)-i-1; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = true
			}
		}
	}
}

bubble_sort_test.go

package bubblesort

import "testing"

func TestBubbleSort(t *testing.T) {
	arr := []int{5, 2, 1, 8, 3, 7}
	BubbleSort(arr)
	t.Log(arr)
}

1.3.3. 测试

=== RUN   TestBubbleSort
    TestBubbleSort: bubble_sort_test.go:8: [1 2 3 5 7 8]
--- PASS: TestBubbleSort (0.00s)
PASS

2. 双向冒泡排序（鸡尾酒排序）

2.1. 简介

冒泡排序是单向从左向右扫描，找出最大一个元素，双向冒泡排序多了一个从右向左找出最小的元素。

2.2. 图示

2.3. 演示

2.3.1. 文件树形图

bubblesort
├── bubble_sort.go
├── bubble_sort_test.go
└── go.mod

2.3.2. 代码

bubble_sort.go

package bubblesort

// 双向冒泡排序
func BubbleSort(arr []int) {
	headIndex, tailIndex := 0, len(arr)-1
	flag := true
	for flag && headIndex < tailIndex {
		flag = false

		// 从左向右扫描
		for j := headIndex; j < tailIndex; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = true
			}
		}
		tailIndex--

		// 从右向左扫描
		for j := tailIndex; j > headIndex; j-- {
			if arr[j] < arr[j-1] {
				arr[j], arr[j-1] = arr[j-1], arr[j]
				flag = true
			}
		}
		headIndex++
	}
}

bubble_sort_test.go

package bubblesort

import "testing"

func TestBubbleSort(t *testing.T) {
	arr := []int{5, 2, 1, 8, 3, 7}
	BubbleSort(arr)
	t.Log(arr)
}

2.3.3. 测试

=== RUN   TestBubbleSort
    TestBubbleSort: bubble_sort_test.go:8: [1 2 3 5 7 8]
--- PASS: TestBubbleSort (0.00s)
PASS

3. 奇偶冒泡排序

3.1. 简介

对数组重复奇交换与偶交换，奇交换：奇索引位与后续1位数据比较如果大于后续则交换，偶交换：偶索引位与后续1位元素比较如果大于后续则交换，一直重复直到，奇交换与偶交换都没有元素交换即整个数组有序。

3.2. 图示

3.3. 演示

3.3.1. 文件树形图

bubblesort
├── bubble_sort.go
├── bubble_sort_test.go
└── go.mod

3.3.2. 代码

bubble_sort.go

package bubblesort

// 奇偶冒泡排序
func BubbleSort(arr []int) {
	oddFlag := true
	evenFlag := true

	for oddFlag || evenFlag{
		oddFlag = false
		// 奇数
		for i := 1; i < len(arr)-1; i+=2 {
			if arr[i] > arr[i+1] {
				arr[i], arr[i+1] = arr[i+1], arr[i]
				oddFlag = true
			}
		}

		evenFlag = false
		// 偶数
		for i := 0; i<len(arr)-1; i+=2 {
			if arr[i] > arr[i+1] {
				arr[i], arr[i+1] = arr[i+1], arr[i]
				evenFlag = true
			}
		}
	}
}

bubble_sort_test.go

package bubblesort

import "testing"

func TestBubbleSort(t *testing.T) {
	arr := []int{5, 1, 2, 8}
	BubbleSort(arr)
	t.Log(arr)
}

3.3.3. 测试

=== RUN   TestBubbleSort
    TestBubbleSort: bubble_sort_test.go:8: [1 2 3 5 7 8]
--- PASS: TestBubbleSort (0.00s)
PASS

4. 参考

• 《C/C++函数与算法速查手册》
• 奇偶排序
• 双向冒泡排序 冒泡排序 性能对比