排序---冒泡排序(Bubble Sort)

一、算法核心概念

冒泡排序是一种简单的交换排序算法 ,其核心思想是:通过重复遍历待排序数组,每次比较相邻的两个元素,若它们的顺序错误(如升序排序中前一个元素大于后一个),则交换它们的位置。经过多轮遍历后,较大的元素会像"气泡"一样逐渐"上浮"到数组的末尾,最终使整个数组有序。

二、基本工作原理

升序排序为例,冒泡排序的工作流程可概括为:

  1. 初始状态:整个数组为"未排序区间"(需排序的元素范围);
  2. 每轮遍历 :从数组头部开始,依次比较相邻元素(arr[j]arr[j+1]),若arr[j] > arr[j+1],则交换两者位置;
  3. 范围收缩:每轮遍历结束后,当前未排序区间中最大的元素会"浮"到区间的末尾,因此下一轮的未排序区间可缩小1个元素(无需再检查已"浮"到末尾的元素);
  4. 终止条件:当某轮遍历中没有发生任何元素交换时,说明数组已完全有序,排序结束。
三、步骤演示(实例解析)

以数组[5, 3, 8, 4, 2]为例,演示升序冒泡排序的过程:

轮次 未排序区间 遍历中的比较与交换 本轮结束后数组 是否发生交换
1 [0,4](全数组) 比较5&3→交换→[3,5,8,4,2]; 比较5&8→不交换; 比较8&4→交换→[3,5,4,8,2]; 比较8&2→交换→[3,5,4,2,8] [3,5,4,2,8]
2 [0,3](前4个元素) 比较3&5→不交换; 比较5&4→交换→[3,4,5,2,8]; 比较5&2→交换→[3,4,2,5,8] [3,4,2,5,8]
3 [0,2](前3个元素) 比较3&4→不交换; 比较4&2→交换→[3,2,4,5,8] [3,2,4,5,8]
4 [0,1](前2个元素) 比较3&2→交换→[2,3,4,5,8] [2,3,4,5,8]
5 [0,0](仅第1个元素) 无相邻元素可比较 [2,3,4,5,8] 否(排序结束)
四、时间复杂度与空间复杂度
  • 时间复杂度

    • 最坏情况:数组完全逆序,需执行n-1轮遍历,每轮比较n-i次(i为轮次),总操作次数为n+(n-1)+...+1 = n(n-1)/2,故为O(n²)
    • 最好情况:数组已完全有序,若添加"交换标志"优化,仅需1轮遍历(n-1次比较)即可判断有序,故为O(n)
    • 平均情况:O(n²)(适用于随机无序数组)。
  • 空间复杂度

    仅需常数个临时变量(用于交换元素和记录标志),故为O(1)(原地排序)。

五、稳定性分析

冒泡排序是稳定的排序算法

  • 稳定性定义:若数组中存在相等元素,排序后它们的相对顺序与原数组一致,则算法稳定。
  • 原因:冒泡排序仅在相邻元素严格逆序 (如arr[j] > arr[j+1])时才交换,若arr[j] == arr[j+1],不会触发交换,因此相等元素的相对顺序保持不变。
六、优化策略

基础版冒泡排序在数组已部分有序时仍会执行不必要的遍历,可通过以下优化提升效率:

1. 交换标志优化(核心优化)

添加一个布尔变量(如swapped),记录每轮是否发生交换。若某轮未发生交换,说明数组已有序,可直接终止排序。

2. 记录最后交换位置(进阶优化)

每轮遍历中,记录最后一次发生交换的位置lastSwapIndex。下一轮遍历的终点可设为lastSwapIndex(因为该位置之后的元素已有序),减少无效比较。

七、C++实现代码
1. 基础版实现
cpp 复制代码
#include <iostream>
#include <vector>
using namespace std;

// 基础版冒泡排序(升序)
void bubbleSortBasic(vector<int>& arr) {
    int n = arr.size();
    // 外层循环:控制轮次(最多n-1轮)
    for (int i = 0; i < n - 1; ++i) {
        // 内层循环:遍历未排序区间[0, n-1-i]
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]); // 交换逆序元素
            }
        }
    }
}

int main() {
    vector<int> arr = {5, 3, 8, 4, 2};
    bubbleSortBasic(arr);
    for (int num : arr) {
        cout << num << " "; // 输出:2 3 4 5 8
    }
    return 0;
}
2. 优化版实现(交换标志+最后交换位置)
cpp 复制代码
#include <iostream>
#include <vector>
using namespace std;

// 优化版冒泡排序(升序)
void bubbleSortOptimized(vector<int>& arr) {
    int n = arr.size();
    int lastSwapIndex = 0; // 记录最后一次交换的位置
    int border = n - 1;    // 当前未排序区间的右边界(初始为数组末尾)
    
    for (int i = 0; i < n - 1; ++i) {
        bool swapped = false; // 标志位:本轮是否发生交换
        // 内层循环仅遍历到border(减少无效比较)
        for (int j = 0; j < border; ++j) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
                lastSwapIndex = j; // 更新最后交换位置
            }
        }
        border = lastSwapIndex; // 收缩未排序区间右边界
        if (!swapped) break;    // 未交换,数组已有序,提前终止
    }
}

int main() {
    vector<int> arr = {5, 3, 8, 4, 2};
    bubbleSortOptimized(arr);
    for (int num : arr) {
        cout << num << " "; // 输出:2 3 4 5 8
    }
    return 0;
}
八、适用场景与局限性
适用场景:
  1. 小规模数据排序 :数据量较小时(如n < 100),冒泡排序实现简单,性能可接受;
  2. 几乎有序的数据:若数组已接近有序(仅少数元素逆序),优化后的冒泡排序可快速完成排序(接近O(n)复杂度);
  3. 教学场景:算法逻辑直观,易于理解,适合作为入门排序算法讲解。
局限性:
  1. 大规模数据效率低 :时间复杂度为O(n²),对于n > 1000的数组,排序速度远低于O(nlogn)级算法(如快速排序、归并排序);
  2. 交换操作频繁:每轮可能发生多次相邻元素交换,实际运行时间比同复杂度的选择排序更长(选择排序每轮仅1次交换)。

冒泡排序是一种直观、简单的排序算法,核心通过"相邻元素比较交换"使大元素逐步上浮。尽管其时间复杂度较高(O(n²)),但在小规模或近乎有序的数据场景中仍有应用价值。通过"交换标志"和"收缩边界"优化,可显著提升其在部分有序数据上的性能。

相关推荐
前端小刘哥5 小时前
现场直播的技术革新者:视频直播点播平台EasyDSS在现场直播场景中的技术应用
算法
草莓工作室5 小时前
数据结构9:队列
c语言·数据结构·队列
violet-lz5 小时前
数据结构八大排序:堆排序-从二叉树到堆排序实现
数据结构·算法
十八岁讨厌编程5 小时前
【算法训练营 · 补充】LeetCode Hot100(上)
算法·leetcode
CandyU26 小时前
C++ 学习 —— 02 - 排序算法
c++·学习·排序算法
一条星星鱼6 小时前
从0到1:如何用统计学“看透”不同睡眠PSG数据集的差异(域偏差分析实战)
人工智能·深度学习·算法·概率论·归一化·睡眠psg
浮灯Foden6 小时前
算法-每日一题(DAY18)多数元素
开发语言·数据结构·c++·算法·leetcode·面试
小欣加油6 小时前
leetcode 844 比较含退格的字符串
算法·leetcode·职场和发展
小龙报6 小时前
《算法每日一题(1)--- 第31场蓝桥算法挑战赛》
c语言·开发语言·c++·git·算法·学习方法
llz_1126 小时前
五子棋小游戏
开发语言·c++·算法