用C++实现交换排序的两种经典算法：冒泡排序与快速排序

本文链接：https://blog.csdn.net/guq511/article/details/147160306

交换排序是计算机科学中最基础的排序算法类别之一，其核心思想是通过不断比较和交换相邻元素来达到排序的目的。本文将详细介绍两种经典的交换排序算法：冒泡排序和快速排序，并提供完整的C++实现代码。

1. 冒泡排序 (Bubble Sort)

算法原理

冒泡排序是最简单的交换排序算法，其基本思想是：

从数组的第一个元素开始，依次比较相邻的两个元素
如果前一个元素大于后一个元素，则交换它们的位置
重复这个过程，直到整个数组有序

由于较大的元素会像"气泡"一样逐渐"浮"到数组的末尾，因此得名冒泡排序。

算法特点

时间复杂度：最好情况O(n)，最坏和平均情况O(n²)
空间复杂度：O(1)，原地排序
稳定排序算法

C++实现

#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; ++i) {
        // 标志位，用于优化，如果某一轮没有发生交换，说明已经有序
        bool swapped = false;
        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        // 如果没有发生交换，提前结束排序
        if (!swapped) break;
    }
}

int main() {
    std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};
    
    std::cout << "排序前: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    bubbleSort(arr);
    
    std::cout << "排序后: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

优化说明

上述实现中加入了swapped标志位进行优化，当某一轮遍历没有发生任何交换时，说明数组已经有序，可以提前终止排序，这在最好情况下可以将时间复杂度降至O(n)。

2. 快速排序 (Quick Sort)

算法原理

快速排序是一种分治算法，由Tony Hoare在1959年提出，其基本思想是：

从数组中选择一个"基准"元素（pivot）
将数组分为两部分：小于基准的元素和大于基准的元素
对这两部分递归地应用快速排序

快速排序的效率很大程度上取决于基准的选择，理想情况下每次都能将数组均匀分割。

算法特点

时间复杂度：最好和平均情况O(n log n)，最坏情况O(n²)
空间复杂度：O(log n)（递归栈空间）
不稳定排序算法

C++实现

#include <iostream>
#include <vector>

// 分区函数，选择最后一个元素作为基准
int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1;       // i是小于基准的区域的最后一个元素的索引
    
    for (int j = low; j < high; ++j) {
        if (arr[j] < pivot) {
            ++i;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1; // 返回基准的最终位置
}

// 快速排序递归函数
void quickSort(std::vector<int>& arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high); // 获取分区点
        
        // 递归排序分区点前后的子数组
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

// 快速排序的包装函数
void quickSort(std::vector<int>& arr) {
    quickSort(arr, 0, arr.size() - 1);
}

int main() {
    std::vector<int> arr = {10, 7, 8, 9, 1, 5};
    
    std::cout << "排序前: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    quickSort(arr);
    
    std::cout << "排序后: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

优化说明

上述实现是最基本的快速排序，实际应用中可以进行多种优化：

基准选择优化：随机选择基准或使用三数取中法，避免最坏情况
小数组优化：对小规模子数组使用插入排序
尾递归优化：减少递归深度
三向切分：处理大量重复元素的情况

两种算法的比较

特性	冒泡排序	快速排序
时间复杂度	O(n²)	O(n log n)平均
空间复杂度	O(1)	O(log n)
稳定性	稳定	不稳定
适用场景	小规模数据或基本有序数据	大规模数据，通用场景
实现难度	简单	中等