冒泡排序算法

原理

---

1. 比较当前元素和下一个元素顺序,如果顺序错误交换顺序.
2. 然后依次往后移,直到判断完所有未排序的数据.
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

源码

---

/**
 * @brief 冒泡排序
 *
 * @param[in] arr      列表
 * @param[in] len      列表长度
 * @param[in] increase 是否从小到大的排序方式
 * @return 0: 执行成功
 */
int sort_bubble(int *arr, uint32_t len, bool increase)
{
    int ret = 0;
    int tmp = 0;
    uint32_t max = len - 1;
    uint32_t i, j;
    if (0 == len || NULL == arr) {
        ret = -1;
        return ret;
    }
    for (i = 0; i < max; i++) {
        for (j = 0; j + i < max; j++) {
            if ((increase && arr[j] > arr[j + 1]) ||
                (!increase && arr[j] < arr[j + 1])) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
    return ret;
}

实测代码

---

#include <stdint.h>
#include <stdbool.h>
#include <sys/time.h>
#include <unistd.h>

#define print_arr(str,arr) do{\
    printf("%s%s%s[%d]={", str == NULL ? "" : str,\
        str == NULL ? "" : ":" , #arr,sizeof(arr) / sizeof(arr[0]));\
    for(unsigned int __i = 0; __i < (sizeof(arr) / sizeof(arr[0]));\
        __i++){\
        printf(",%d"+!__i, arr[__i]);\
    }\
    printf("};\n");\
}while(0)

int main(int argc, char **argv)
{
    int arr[] = {100, 34, 123, 98, 1, 0, -1, 23, 100, 345};
    print_arr("Source", arr);
    sort_bubble(arr, sizeof(arr) / sizeof(arr[0]), true);
    print_arr("Increase", arr);
    sort_bubble(arr, sizeof(arr) / sizeof(arr[0]), false);
    print_arr("Decrease", arr);
}

执行结果

Source:arr[10]={100,34,123,98,1,0,-1,23,100,345};
Increase:arr[10]={-1,0,1,23,34,98,100,100,123,345};
Decrease:arr[10]={345,123,100,100,98,34,23,1,0,-1};

算法优化

---

在某些情况下，如队列本身或剩余数据就是正确顺序，那么按照之前的代码，依旧会继续一轮一轮的比较，后续的比较就是无意义的比较了，所以当检测到某一轮就是正确顺序后，就应该退出排序。

int sort_bubble(int *arr, uint32_t len, bool increase)
{
    int ret = 0;
    int tmp = 0;
    /**
     * 数据的顺序排好之后，冒泡算法仍然会继续进行下一轮的比较，
     * 直到(len-1)次，所以后面的比较都是无意义的.
     * 当某一轮的比较都不需要交换次序的时候,判定为剩下的数据顺序已经正确,
     * 退出排序流程.
     */
    bool disorder = true; /*!< 队列是否为混乱序 */
    uint32_t max = len - 1;
    uint32_t i, j;
    if (0 == len || NULL == arr) {
        ret = -1;
        return ret;
    }
    for (i = 0; i < max && disorder; i++) {
        disorder = false;
        for (j = 0; j + i < max; j++) {
            if ((increase && arr[j] > arr[j + 1]) ||
                (!increase && arr[j] < arr[j + 1])) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                disorder = true;
            }
        }
        printf("%d\n", i); /*!< 测试代码 */
    }
    return ret;
}

##　测试
若队列为int arr[] = {-100, -50, -20, -10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 24, 46, 68, 100};,
原有的代码排成升序则需要执行19轮,优化后只需要执行1轮。当然了是否需要如此修改还是需要看实际场景这种概率是否比较大，计较偶尔多循环几轮和每轮都多一次判断所消耗的时间损耗。

参考文献

---

1. 十大经典排序算法（动图演示）.
2. 冒泡排序-百度百科.