冒泡排序的缺陷及优化

不只会拍照的程序猿2025-02-15 11:18

冒泡排序的缺陷及优化

定义：

冒泡排序（Bubble Sort）是一种简单且常用的排序算法。其基本思想是通过多次遍历待排序的序列，依次比较相邻的两个元素，并根据需要交换它们的位置，使得较大的元素逐渐向后移动，较小的元素逐渐向前移动。这个过程类似于水中的气泡逐渐上升，因此得名"冒泡排序"。

操作步骤

  1. 比较第 1 个和第 2 个元素，按大小排序。

  2. 移动到下 1 个对（第 2 和第 3），继续比较和排序。

  3. 重复这个过程，每轮结束后将最大（小）的数"沉"到数组末尾。

实现

基本实现：冒泡排序

分析

排序过程如下图所示：

  • 设定数组长度为n。

  • 外层循环用于控制总的遍历次数，最多需要 n-1 次。

  • 内存循环用于比较并排序相邻元素。

  • 每经过一轮遍历，总会把当前遍历最后一个数放在最末未，所以内循环次数随着外循环次数增加而减少。具体关系为：当前内循环次数 = n - 1 - 当前外循环次数 。

代码

使用冒泡排序方法，从大到小排序数据。编写代码如下

go 复制代码 
/**
 * @ 基本实现：冒泡排序
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */ 
void bubble_sort(int *arr, int num)
{
    int i, j, tmp;

    for (i=0; i<num-1; i++) {
        for (j=0; j<num-i-1; j++) {
            if (arr[j] < arr[j+1]) {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

}

运行结果

优化 1. 短路法

分析

  • 由上图可以看出，在第 1 轮遍历完成，就已经得到我们需要的排序顺序，此时第 2 、3、4 轮遍历数据完全无交换过程（浪费时间）。

  • 当某一轮遍历数据完全无交换即可表示此时我们的排序已完成，可以完全跳过后序遍历。从而提高排序效率。

  • 此功能在数据本身是有序的情况下将会大大减少排序过程。

代码

在冒泡的基础上，加入短路判断，若当前排序已完成，提前退出排序。编写代码如下

go 复制代码 
/**
 * @ 优化 1：冒泡排序，短路优化，如果某一轮没有发生交换，说明数组已经排序完成，提前退出。
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */ 
void bubble_sort_short_circuit(int *arr, int num)
{
    int i, j, tmp;
    char change_flag = 0;   /* 交换标志，1表示当前有交换 */

    for (i=0; i<num-1; i++) {
        change_flag = 0;
        for (j=0; j<num-i-1; j++) {
            if (arr[j] < arr[j+1]) {    /* 数据不符合从大到小规则，交换 */
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                change_flag = 1;
            }
        }

        /* 若是某一轮没有发生交换，说明数组已经排序完成，提前退出 */
        if (!change_flag) {
            printf("quit i[%d] j[%d]\n", i, j);
            break;
        }
    }
}
运行结果

优化 2.鸡尾酒排序

分析

  • 为进一步提高效率，采用双向扫描的方式。

  • 设定左右指针 left 和 right。

  • 在每 1 轮中进行 2 次扫描------从左到右将较大的元素移到右边，再从右到左将较小的元素移到左边。

  • 如果某次循环没有发生任何交换，说明数组已排序完成。

代码

使用鸡尾酒排序方式。编写代码如下

go 复制代码 
/**
 * @ 优化 2：鸡尾酒排序，每一轮遍历先从左到右，再从右到左，可以更快减少未排序数据。
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */ 
void cocktail_shaker_sort(int *arr, int num)
{
    int i, tmp;
    char change_flag = 1;           /* 交换标志，1表示当前有交换 */
    int left = 0, right = num-1;    /* 用于控制左右遍历 */

    while ((left <= right) && change_flag) {
        change_flag = 0;
        /* 从左至右，将最小的数移动到最后面 */
        for (i=left; i<right; i++) {
            if (arr[i] < arr[i+1]) { 
                tmp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = tmp;
                change_flag = 1;
            }
        }
        left++;

        /* 从右至左，将最大的数移动到最前面 */
        for (i=right-1; i>=left; i--) {
            if (arr[i] > arr[i-1]) { 
                tmp = arr[i];
                arr[i] = arr[i-1];
                arr[i-1] = tmp;
                change_flag = 1;
            }
        }
        right--;
    }
}
运行结果

完整代码

go 复制代码 
/**
 * @Filename : bubble_sort.c
 * @Revision : $Revision: 1.00 $
 * @Author : Feng(更多编程相关的知识和源码见微信公众号：不只会拍照的程序猿，欢迎订阅)
 * @Description : 冒泡排序的缺陷及优化
**/

#include <stdio.h>
#include <string.h>

#define MAX_NUM     5  

/**
 * @ 打印数组
 * @ arr - 待打印的数组     num - 数组元素个数
 * */
void print_arr(int *arr, int num) 
{
    int i;

    for (i=0; i<num; i++)
        printf("%02d ", arr[i]);
    printf("\n");
}

/**
 * @ 基本实现：冒泡排序
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */
void bubble_sort(int *arr, int num)
{
    int i, j, tmp;

    printf("排序前数组内容: ");
    print_arr(arr, num);

    for (i=0; i<num-1; i++) {
        for (j=0; j<num-i-1; j++) {
            if (arr[j] < arr[j+1]) {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
            printf("第%d轮第%d次排序: ", i+1, j+1);
            print_arr(arr, num);
        }
    }

    printf("排序后数组内容: ");
    print_arr(arr, num);
}

/**
 * @ 优化 1：冒泡排序，短路优化，如果某一轮没有发生交换，说明数组已经排序完成，提前退出。
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */
void bubble_sort_short_circuit(int *arr, int num)
{
    int i, j, tmp;
    char change_flag = 0;   /* 交换标志，1表示当前有交换 */

    printf("排序前数组内容: ");
    print_arr(arr, num);

    for (i=0; i<num-1; i++) {
        change_flag = 0;
        for (j=0; j<num-i-1; j++) {
            if (arr[j] < arr[j+1]) {    /* 数据不符合从大到小规则，交换 */
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
                change_flag = 1;
            }
            printf("第%d轮第%d次排序: ", i+1, j+1);
            print_arr(arr, num);
        }

        /* 若是某一轮没有发生交换，说明数组已经排序完成，提前退出 */
        if (!change_flag) {
            //printf("quit i[%d] j[%d]\n", i, j);
            break;
        }
    }

    printf("排序后数组内容: ");
    print_arr(arr, num);
}

/**
 * @ 优化 2：鸡尾酒排序，每一轮遍历先从左到右，再从右到左，可以更快减少未排序数据。
 * @ arr - 待排序的数组     num - 数组元素个数
 * @ 要求从大到小排序数据
 * */
void cocktail_shaker_sort(int *arr, int num)
{
    int i, tmp;
    char change_flag = 0;           /* 交换标志，1表示当前有交换 */
    int left = 0, right = num-1;    /* 用于控制左右遍历 */
    int cnt = 0, cntleft, cntright; /* 记录排序次数 */

    printf("排序前数组内容: ");
    print_arr(arr, num);

    while (left <= right) {       
        /* 从左至右，将最小的数移动到最后面 */
        change_flag = 0;
        cntleft = 0;
        cntright = 0;
        for (i=left; i<right; i++) {
            if (arr[i] < arr[i+1]) { 
                tmp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = tmp;
                change_flag = 1;
            }
            cntleft++;
            printf("第%d轮第%d次排序(从左至右): ", cnt+1, cntleft);
            print_arr(arr, num);
        }
        if (!change_flag)
            break;
        left++;

        /* 从右至左，将最大的数移动到最前面 */
        change_flag = 0;
        for (i=right-1; i>=left; i--) {
            if (arr[i] > arr[i-1]) { 
                tmp = arr[i];
                arr[i] = arr[i-1];
                arr[i-1] = tmp;
                change_flag = 1;
            }
            cntright++;
            printf("第%d轮第%d次排序(从右至左): ", cnt+1, cntright);
            print_arr(arr, num);
        }
        
        if (!change_flag)
            break;
            
        right--;
        cnt++;
    }

    printf("排序后数组内容: ");
    print_arr(arr, num);
}

int main(void)
{
    int buf0[] = {3, 8, 5, 1, 2};
    int buf1[] = {3, 8, 5, 1, 2};
    int buf2[] = {3, 8, 5, 1, 2};
    
    printf ("----------冒泡排序---------\n");
    bubble_sort(buf0, MAX_NUM);

    printf ("----------短路优化---------\n");
    bubble_sort_short_circuit(buf1, MAX_NUM);

    printf ("---------鸡尾酒排序---------\n");
    cocktail_shaker_sort(buf2, MAX_NUM);
    
    return0;
}

运行结果

总结

复杂度

  • 时间复杂度：最坏情况下为O(n²)，平均情况下也为O(n²)，效率较低。

  • 空间复杂度：O(1)，属于原地排序算法。

优点

  • 实现简单，易于理解和实现。

  • 空间复杂度低，属于原地排序算法。

缺点

  • 时间复杂度较高，不适合大规模数据的处理。

  • 对于最坏情况（数组完全逆序），效率低下。

优化

  • 短路优化：若某一轮遍历中完全没发生交换，可以提前结束。这在最好情况下非常有效。

  • 鸡尾酒排序：双向遍历，可以更快将元素放到正确位置，减少比较次数。

总结

冒泡排序虽然在实际应用中并不常用，但由于其简单性和教学价值，常被用作学习排序算法的基础。对于小规模数据或需要简单排序的情况，它仍是一个不错的选择。通过了解冒泡排序的基本原理和优化版本，我们可以更好地理解更复杂的排序算法的设计思想。

相关推荐
pusue_the_sun3 分钟前
C语言强化训练（12）
c语言·开发语言·算法
小欣加油8 分钟前
leetcode 6 Z字形变化
c++·算法·leetcode·职场和发展
youzjuer20 分钟前
算法之二叉树
算法·深度优先
失散1330 分钟前
分布式专题——1.1 Redis单机、主从、哨兵、集群部署
java·数据库·redis·分布式·架构
刘一说30 分钟前
Linux调试命令速查：Java/微服务必备
java·linux·微服务
IT·陈寒38 分钟前
怎么这么多 StringUtils —— Apache、Spring、Hutool 全面对比
java·spring·apache
2401_8588698039 分钟前
支持向量机
算法·机器学习·支持向量机
用户4822137167751 小时前
深度学习——卷积神经网络
算法
AAA修煤气灶刘哥1 小时前
MySQL 查文本查哭了？来唠唠 ES 这货：从 “啥是 ES” 到 Java 撸代码，一篇整明白！
java·后端·elasticsearch
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！022025年数学建模国赛C题超详细解题思路032025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定04UV安装并设置国内源052025高教社杯国赛数学建模选题建议+初步分析062025国赛B题保姆级教程思路分析 碳化硅外延层厚度的确定07奈飞工厂官网，国内Netflix影视在线看|中文网页电脑版入口08KGG转MP3工具|非KGM文件|解密音频09（E题｜AI 辅助智能体测）2025年高教杯全国大学生数学建模国赛解题思路|完整代码论文集合10Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code