Go语言数组排序（冒泡排序法）—— 用最直观的方式掌握排序算法

一、案例目标

本案例将使用最经典的排序算法之一——冒泡排序（Bubble Sort），对一组整数进行从小到大的排序。通过本案例，掌握基本排序思维与切片操作，为后续掌握更复杂的排序算法打基础。

二、应用场景举例

• • 排序成绩、价格、分数等数据
• • 理解常见算法执行原理
• • 后续学习快速排序、归并排序、堆排序的基础

三、涉及知识点讲解

四、🛠 实现需求

1. 1. 用户输入一组整数（用空格分隔）；
2. 2. 程序将这些数字进行冒泡排序；
3. 3. 输出排序前与排序后的数组；
4. 4. 包含基础的错误处理（输入不规范）；

五、完整代码实现

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    fmt.Println("请输入一组整数（用空格分隔）：")
    reader := bufio.NewReader(os.Stdin)
    input, _ := reader.ReadString('\n')

    // 字符串转整数切片
    nums, err := parseInput(input)
    if err != nil {
        fmt.Println("输入有误，请只输入整数！")
        return
    }

    fmt.Println("排序前：", nums)

    bubbleSort(nums)

    fmt.Println("排序后：", nums)
}

// 冒泡排序核心逻辑
func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        // 提前结束标志位
        swapped := false
        for j := 0; j < n-i-1; j++ {
            if arr[j] > arr[j+1] {
                // 交换
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = true
            }
        }
        // 若没有发生交换，说明已经有序
        if !swapped {
            break
        }
    }
}

// 将输入字符串转为整数切片
func parseInput(input string) ([]int, error) {
    fields := strings.Fields(input)
    var nums []int
    for _, f := range fields {
        n, err := strconv.Atoi(f)
        if err != nil {
            return nil, err
        }
        nums = append(nums, n)
    }
    return nums, nil
}

六、运行示例

示例输入：

请输入一组整数（用空格分隔）：
9 3 5 1 8

输出结果：

排序前： [9 3 5 1 8]
排序后： [1 3 5 8 9]

七、核心算法解释

冒泡排序的基本思路是：

• • 每次遍历将当前最大值“冒泡”到末尾
• • 每轮比较的次数逐渐减少
• • 若一轮中未发生交换，则提前结束（优化点）

图示演示：

初始：[9 3 5 1 8]
第一轮：[3 5 1 8 9]
第二轮：[3 1 5 8 9]
第三轮：[1 3 5 8 9]
第四轮：无交换，提前退出

八、 拓展练习建议

1. 1. 实现从大到小排序；
2. 2. 改为选择排序、插入排序；
3. 3. 排序对象为字符串数组；
4. 4. 改写为支持浮点数排序；
5. 5. 统计交换次数与比较次数；

九、常见错误提示

小结

通过本案例你掌握了：

• • 如何接收用户一组数据输入
• • 如何将字符串解析为整数切片
• • 如何使用冒泡排序对数组进行排序
• • 如何在Go中进行值交换与切片操作

冒泡排序虽然效率不高，但逻辑清晰，是理解“比较+交换”类排序算法的入门利器。