冒泡排序算法

一、冒泡排序简介 

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的列表，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历列表的工作是重复地进行直到列表中没有需要交换的元素，这意味着列表已经排序完成。

冒泡排序的基本步骤：

1. 比较相邻的元素。如果第一个比第二个大（升序排序），则交换它们。
2. 对每一对相邻元素重复以上步骤，从开始第一对到结尾的最后一对。这样，在每一轮遍历之后，最大的元素就会被移到列表的末尾。
3. 重复以上步骤，除了最后一个元素以外，每次遍历都减少一个元素。

二、冒泡排序图解

三、冒泡代码实现 

冒泡排序部分代码：

通过自定义函数内部实现冒泡排序算法，my_bubble函数接收一维数组array、元素总数num、字符串str三个参数，通过双for循环实现内循环交换，外循环遍历。最终实现从小到大或者从大到小的整数元素的排序功能。

// 冒泡排序1
int my_bubble(int array[], int num, string str) {
    for (int i = 0; i < num - 1; ++i) {
        for (int j = 0; j < num - 1 - i; ++j) {
            if (str == "大") {
                // 从小到大排序
                if (array[j] > array[j + 1]) {
                    swap(array[j], array[j + 1]);
                }
            } else if (str == "小") {
                // 从大到小排序
                if (array[j] < array[j + 1]) {
                    swap(array[j], array[j + 1]);
                }
            } else {
                cout << "非法字符，结束排序！" << endl;
                return -1;
            }
        }
    }
    return 0;
}


// 冒泡排序2
int my_bubble(int array[], int num, string str) {
    for (int i = 0; i < num - 1; ++i) {
        for (int j = 0; j < num - 1 - i; ++j) {
            if (str == "大") {
                // 从小到大排序
                if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
            } else if (str == "小") {
                // 从大到小排序
                if(array[j] < array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
            } else {
                cout << "非法字符，结束排序！" << endl;
                return -1;
            }
        }
    }
    return 0;
}

 my_bubble.cpp完整代码：

#include <iostream>
#include <sstream>
#include <limits>
using namespace std;

// 函数声明
void my_input_number(int array[], int num);
int my_bubble(int array[], int num, string str);
void my_print(int array[], int num);

// 存储输入的数字到数组
void my_input_number(int array[], int num) {
    cout << "请输入 " << num << " 个整数：";
    for (int i = 0; i < num; ++i) {
        cin >> array[i];
    }
}

// 冒泡排序
int my_bubble(int array[], int num, string str) {
    for (int i = 0; i < num - 1; ++i) {
        for (int j = 0; j < num - 1 - i; ++j) {
            if (str == "大") {
                // 从小到大排序
                if (array[j] > array[j + 1]) {
                    swap(array[j], array[j + 1]);
                }
            } else if (str == "小") {
                // 从大到小排序
                if (array[j] < array[j + 1]) {
                    swap(array[j], array[j + 1]);
                }
            } else {
                cout << "非法字符，结束排序！" << endl;
                return -1;
            }
        }
    }
    return 0;
}

// 打印排序后的数组
void my_print(int array[], int num) {
    cout << "排序后的数组：" << endl;
    for (int i = 0; i < num; ++i) {
        cout << array[i] << " ";
    }
    cout << endl;
}

int main() {
    const int MAX_SIZE = 100; // 假设数组最大长度为100
    int array[MAX_SIZE];
    int num;
    string str;

    cout << "请输入数组长度：";
    while (!(cin >> num) || num <= 0 || num > MAX_SIZE) {
        cout << "无效的数组长度！请输入一个有效的正整数：";
        cin.clear();             // 清除错误标志
        cin.ignore(numeric_limits<streamsize>::max(), '\n'); // 清空输入缓冲区
    }

    cout << "请输入排序要求（'大' 表示从小到大排序，'小' 表示从大到小排序）：";
    while (!(cin >> str) || (str != "大" && str != "小")) {
        cout << "无效的排序要求！请输入 '大' 或 '小': ";
        cin.clear();             // 清除错误标志
        cin.ignore(numeric_limits<streamsize>::max(), '\n'); // 清空输入缓冲区
    }

    my_input_number(array, num); // 存储输入的数字到数组
    my_bubble(array, num, str);  // 对数组进行排序
    my_print(array, num);        // 打印排序后的数组

    return 0;
}

四、总结 

运行结果：

 

ps：为避免代码过长和本着应用代码和提高效率目的，交换元素直接调用swap函数，参考如下： 

细节：相邻两个元素之间看成一个对组，内部进行大小比较，（外层for循环i<num-1即可的原因）外部则是步进一位，每进一位，步数少一（内层for循环j<num-1-i的原因）。

小结：冒泡排序的时间复杂度为O(n^2)，其中num是要排序的元素数量。它是相邻两个元素之间进行比较的一种稳定的排序算法，适合于少量元素的排序或者是已经基本有序的情况下，冒泡排序的有趣现象，按从小到大排序，每一轮排序过后，最大值就排在最后面，仿佛水面的泡泡现象，底部冒泡，从低往上泡泡越来越大，有趣的是我还没有见过按从大到小排序，每经过一轮排序，最小值排在最后面，仿佛底部的泡泡最大的，底部冒泡，从低往上泡泡越来越小的情况有哪位同学见到过吗？