四种排序 C++ 通俗易懂代码（中小学生专用）

说明

1. 全部代码带超详细注释，简单逻辑，无复杂语法
2. 统一功能：输入一组数字，排序后输出
3. 四种算法：冒泡、选择、插入、桶排序
4. 适合初中信息学，变量名简单易懂

1. 冒泡排序（Bubble Sort）

原理：像水里气泡，大数慢慢浮到后面

相邻两个数对比，左边比右边大就交换，一轮把最大数移到末尾，重复直到有序

#include <iostream>
using namespace std;

int main() {
    // 要排序的数字数组
    int arr[10] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    // 数组长度，一共10个数字
    int n = 10;

    // 外层循环：一共需要n-1轮冒泡
    for (int i = 0; i < n - 1; i++) {
        // 内层循环：每一轮比较到倒数第i个（后面i个已经排好）
        for (int j = 0; j < n - 1 - i; j++) {
            // 如果左边数字 > 右边数字，交换两个数
            if (arr[j] > arr[j + 1]) {
                // 临时变量存一下，完成交换
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 输出排序结果
    cout << "冒泡排序结果：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

2. 选择排序（Selection Sort）

原理：每一轮找到最小数字，放到当前最前面

先找未排序区域最小值，和当前首位交换，逐步排好前面

#include <iostream>
using namespace std;

int main() {
    int arr[10] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    int n = 10;

    // i代表当前要放最小值的位置
    for (int i = 0; i < n - 1; i++) {
        // 假设当前i位置是最小值下标
        int minIndex = i;

        // 从i后面全部数字找更小的数
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // 更新最小值下标
            }
        }

        // 把最小值 和 i位置数字交换
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }

    // 打印结果
    cout << "选择排序结果：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

3. 插入排序（Insert Sort）

原理：模拟打牌，逐个拿数字插入前面有序队列

前面是有序数组，每次取后面一个数字，向前对比插入到正确位置

#include <iostream>
using namespace std;

int main() {
    int arr[10] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    int n = 10;

    // 从第二个数开始（第一个数默认有序）
    for (int i = 1; i < n; i++) {
        // 取出当前要插入的数字
        int val = arr[i];
        // j指向i前一位，向前遍历有序区
        int j = i - 1;

        // 只要前面数字比val大，就往后挪一位
        while (j >= 0 && arr[j] > val) {
            arr[j + 1] = arr[j];
            j--;
        }
        // 空出来的j+1位置放入val
        arr[j + 1] = val;
    }

    cout << "插入排序结果：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

4. 桶排序（Bucket Sort，简单版，适合0~9整数）

原理：准备10个桶（0-9），数字是几就放进几号桶，最后依次倒出

只适合范围小的整数，速度最快，逻辑最简单，小学生好理解

#include <iostream>
using namespace std;

int main() {
    // 待排序数字（范围0~9）
    int arr[10] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    int n = 10;

    // 创建10个桶，bucket[0]存数字0的个数，bucket[1]存数字1的个数...
    int bucket[10] = {0};

    // 第一步：把所有数字丢进对应桶，计数
    for (int i = 0; i < n; i++) {
        int num = arr[i];
        bucket[num]++; // 对应桶数量+1
    }

    // 第二步：按桶从小到大取出数字，放回原数组
    int idx = 0; // 记录数组存放位置
    for (int i = 0; i < 10; i++) {
        // 当前桶有几个数字，就循环输出几次
        while (bucket[i] > 0) {
            arr[idx] = i;
            idx++;
            bucket[i]--;
        }
    }

    cout << "桶排序结果：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

四种算法简单对比（背诵版）

1. 冒泡排序：相邻对比交换，大数上浮，代码最简单，但慢
2. 选择排序：每次找最小放最前面，交换次数少
3. 插入排序：像整理扑克牌，数据接近有序时速度很快
4. 桶排序：数字范围小时最快，只能排小范围整数

统一可运行整合版（四段放一起，一键运行看全部结果）

#include <iostream>
using namespace std;

// 打印数组工具函数，减少重复代码
void printArr(int arr[], int n, string name) {
    cout << name << "：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    int raw[10] = {5, 3, 8, 1, 9, 2, 7, 4, 6, 0};
    int n = 10;

    // ========== 1.冒泡排序 ==========
    int bub[10];
    for(int i=0;i<10;i++) bub[i]=raw[i];
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (bub[j] > bub[j + 1]) {
                int t = bub[j];
                bub[j] = bub[j + 1];
                bub[j + 1] = t;
            }
        }
    }
    printArr(bub, n, "冒泡排序");

    // ========== 2.选择排序 ==========
    int sel[10];
    for(int i=0;i<10;i++) sel[i]=raw[i];
    for (int i = 0; i < n - 1; i++) {
        int minI = i;
        for (int j = i + 1; j < n; j++) {
            if (sel[j] < sel[minI]) minI = j;
        }
        int t = sel[i];
        sel[i] = sel[minI];
        sel[minI] = t;
    }
    printArr(sel, n, "选择排序");

    // ========== 3.插入排序 ==========
    int ins[10];
    for(int i=0;i<10;i++) ins[i]=raw[i];
    for (int i = 1; i < n; i++) {
        int val = ins[i];
        int j = i - 1;
        while (j >= 0 && ins[j] > val) {
            ins[j + 1] = ins[j];
            j--;
        }
        ins[j + 1] = val;
    }
    printArr(ins, n, "插入排序");

    // ========== 4.桶排序 ==========
    int buc[10];
    for(int i=0;i<10;i++) buc[i]=raw[i];
    int bucket[10] = {0};
    for (int i = 0; i < n; i++) bucket[buc[i]]++;
    int pos = 0;
    for (int i = 0; i < 10; i++) {
        while (bucket[i] > 0) {
            buc[pos++] = i;
            bucket[i]--;
        }
    }
    printArr(buc, n, "桶排序");

    return 0;
}