一、冒泡排序
package main
import "fmt"
func BubbleSort(arr []int) {
/*
思路：将大的元素一步一步"冒泡"到最后
*/
l := len(arr)
for i := 0; i < l-1; i++ {
exchange := false
for j := 0; j < l-1-i; j++ { // l-1 是因为只需要遍历到数组的倒数第二个元素，此时就可以拿这个元素和最后一个元素比较了
if arr[j] > arr[j+1] {
arr[j], arr[j+1] = arr[j+1], arr[j]
exchange = true
}
}
if !exchange {
return
}
}
}
func main() {
arr := []int{5, 17, 1, 68, 22}
fmt.Println("排序前：", arr)
BubbleSort(arr)
fmt.Println("排序后：", arr)
}
二、选择排序
package main
import "fmt"
func SelectSort(arr []int) {
/*
思路：
1.把第一个没有排序过的元素设置为最小值
2.遍历每个没有排序过的元素
如果元素 < 现在的最小值
将此元素设置成为新的最小值
3.经过步骤2后，如果最小值发生改变，则将最小值和第一个没有排序过的位置交换
*/
l := len(arr)
for i := 0; i < l-1; i++ { // l-1 是因为最后一个元素不需要比较了
/*
无序区间：
第一次：[0, l-1]
第二次：[1, l-1]
...
*/
minIndex := i // 记录最小值的索引
for j := i+1; j < l; j++ { // i+1 表示自己不用跟自己比
if arr[j] < arr[minIndex] {
minIndex = j // 更新最小值索引
}
}
if i != minIndex { // i 不是最小值时，将 i 和最小值进行交换
arr[i], arr[minIndex] = arr[minIndex], arr[i]
}
}
}
func main(){
arr := []int{5, 17, 1, 68, 22}
fmt.Println("排序前：", arr)
SelectSort(arr)
fmt.Println("排序后：", arr)
}
三、插入排序
package main
import "fmt"
func InsertSort(arr []int) {
/*
思路：
1.将第一个元素标记为已排序
2.遍历每个没有排序过的元素，将每次遍历的第一个元素用临时变量保存
因为：
第一次遍历从索引 1 开始
第二次遍历从索引 2 开始
所以：
设遍历索引为 i （从1开始），则临时变量保存的元素是 arr[i]
3.如果排序过的最后一个元素 > 临时保存的元素，则将排序过的元素向右移一格；否则，插入这个临时保存的元素
*/
l := len(arr)
for i := 1; i < l; i ++ { // i = [1, 2, 3... l-1]
temp := arr[i] // temp用来保存未排序序列的第一个元素
prevIndex := i - 1 // 已排序序列的最后一个元素索引
for ; prevIndex >=0 && arr[prevIndex] > temp; {
arr[prevIndex + 1] = arr[prevIndex] // 右移
prevIndex -= 1 // 右移过后，temp还要和有序序列的每个元素从后向前依次比较，所以 prevIndex 自减 1
}
arr[prevIndex + 1] = temp // 经过上面的循环右移，直到条件不满足，则将 temp 插入索引为 prevIndex 元素的后面
}
}
func main() {
arr := []int{5, 17, 1, 68, 22}
fmt.Println("排序前：", arr)
InsertSort(arr)
fmt.Println("排序后：", arr)
}
四、快速排序
package main
import "fmt"
func QuickSort(arr []int) {
quickSort(arr, 0, len(arr)-1)
}
func quickSort(arr []int, left, right int) []int {
if left < right {
partitionIndex := partition(arr, left, right)
quickSort(arr, left, partitionIndex-1)
quickSort(arr, partitionIndex+1, right)
}
return arr
}
func partition(arr []int, left, right int) int {
temp := arr[left] // 基准(pivot)元素
for ; left < right; {
// 从序列右边往左边找，直到找到比基准小的元素才退出循环
for ; left < right && arr[right] >= temp; {
right -= 1
}
arr[left] = arr[right] // 将这个元素"左移"
// 从序列左边往右边找，直到找到比基准大的元素才退出循环
for ; left < right && arr[left] <= temp; {
left += 1
}
arr[right] = arr[left] // 将这个元素"右移"
}
arr[left] = temp // 相当于将基准元素放到"中间"，此时基准元素左边都是小于基准元素的元素，右边同理
return left
}
func main() {
arr := []int{5, 17, 1, 68, 22}
fmt.Println("排序前：", arr)
QuickSort(arr)
fmt.Println("排序后：", arr)
}
