C++-经典排序算法的详细解析-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_73139914/article/details/143086136

经典排序算法的详细解析

排序算法是计算机科学中一个重要的主题，其目标是将一组数据按照一定的顺序排列（通常为升序或降序）。排序算法可以按照不同的标准进行分类，例如比较排序与非比较排序、稳定排序与不稳定排序、原地排序与非原地排序等。在本篇文章中，我们将详细分析几种经典的排序算法，包括它们的实现、时间复杂度、空间复杂度及应用场景。

1. 冒泡排序（Bubble Sort）

算法概述

冒泡排序是一种简单的排序算法，它重复地遍历待排序的列表，比较相邻的元素并交换顺序错误的元素。遍历列表的工作是重复进行的，直到没有再需要交换的元素为止。

算法实现

#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 - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]); // 交换元素
                swapped = true;
            }
        }
        // 如果没有交换，数组已经是有序的
        if (!swapped) break;
    }
}

时间复杂度

最优时间复杂度：O(n) （当输入数组已经有序时）
平均和最坏时间复杂度：O(n^2)

空间复杂度

O(1)（原地排序）

应用场景

由于冒泡排序的低效性，它常常用于教学目的而非实际应用。在某些特定情况下，如果数据量很小，冒泡排序可以是一个简单的选择。

2. 选择排序（Selection Sort）

算法概述

选择排序是一种简单的排序算法，其工作原理是反复地选择剩余元素中最小的元素，并将其放到已排序序列的末尾。

算法实现

#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // 找到最小值的索引
            }
        }
        std::swap(arr[i], arr[minIndex]); // 交换
    }
}

时间复杂度

最优、平均及最坏时间复杂度：O(n^2)

空间复杂度

O(1)（原地排序）

应用场景

选择排序不适合大量数据的排序，但它的优点在于简单且容易实现。此外，它对小型数据集表现良好。

3. 插入排序（Insertion Sort）

算法概述

插入排序通过将每个新元素插入到已排序的部分中来构建最终的排序数组。对于每个元素，它与已排序部分的元素比较，直到找到合适的插入位置。

算法实现

#include <iostream>
#include <vector>

void insertionSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int key = arr[i]; // 当前要插入的元素
        int j = i - 1;
        // 将大于 key 的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key; // 插入
    }
}

时间复杂度

最优时间复杂度：O(n) （当输入数组已近乎有序时）
平均和最坏时间复杂度：O(n^2)

空间复杂度

O(1)（原地排序）

应用场景

插入排序在某些情况下表现良好，尤其是在部分有序的数组，并且它在小规模数据中非常有效。

4. 快速排序（Quick Sort）

算法概述

快速排序是一种高效的排序算法，它通过分治法将数组分为两部分，分别对两部分进行排序。选定一个”基准“（pivot），小于基准的元素放左边，大于基准的元素放右边，然后递归排序。

算法实现

#include <iostream>
#include <vector>

int partition(std::vector<int>& arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1; // 小于基准的元素的索引
    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); // 递归排序右边
    }
}

时间复杂度

最优与平均时间复杂度：O(n log n)
最坏时间复杂度：O(n^2) （当数组已经是有序时）

空间复杂度

O(log n) （递归栈空间）

应用场景

快速排序是广泛使用的排序算法，尤其适用于大规模数据集。尽管在最坏情况下性能较差，但通常情况下表现良好。

5. 归并排序（Merge Sort）

算法概述

归并排序是一种基于分治法的排序算法，将数组分成两半，分别排序，然后将两个已排序的部分合并在一起，最终组成一个完整的排序数组。

算法实现

#include <iostream>
#include <vector>

void merge(std::vector<int>& arr, int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;

    std::vector<int> L(n1), R(n2); // 创建临时数组

    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(std::vector<int>& arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;

        mergeSort(arr, left, mid); // 排序左边
        mergeSort(arr, mid + 1, right); // 排序右边
        merge(arr, left, mid, right); // 合并
    }
}

时间复杂度

最优、平均和最坏时间复杂度：O(n log n)

空间复杂度

O(n) （需要临时数组存储数据）

应用场景

归并排序在大型数据集的排序任务中表现出色，特别适合处理链表和外部排序（如在硬盘上操作大数据集）。

6. 堆排序（Heap Sort）

算法概述

堆排序是基于比较的排序算法，它利用堆这种数据结构。排序的过程分为两个阶段：构建最大堆以及将当前最大值与最后一个元素交换并同时减少堆的大小。

算法实现

#include <iostream>
#include <vector>

void heapify(std::vector<int>& arr, int n, int i) {
    int largest = i; // 初始化最大值为根节点
    int left = 2 * i + 1; // 左子节点
    int right = 2 * i + 2; // 右子节点

    // 如果左子节点大于根节点
    if (left < n && arr[left] > arr[largest])
        largest = left;

    // 如果右子节点大于当前最大值
    if (right < n && arr[right] > arr[largest])
        largest = right;

    // 如果最大值不是根节点
    if (largest != i) {
        std::swap(arr[i], arr[largest]); // 交换
        heapify(arr, n, largest); // 递归
    }
}

void heapSort(std::vector<int>& arr) {
    int n = arr.size();

    // 构建最大堆
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // 一个个提取元素从堆中
    for (int i = n - 1; i > 0; i--) {
        std::swap(arr[0], arr[i]); // 交换
        heapify(arr, i, 0); // 重新形成堆
    }
}

时间复杂度

最优、平均和最坏时间复杂度：O(n log n)

空间复杂度

O(1) （原地排序）

应用场景

堆排序通常用于需要保证最坏表现的地方，例如在不希望引入大量额外内存的情况下进行排序。

7. 希尔排序（Shell Sort）

算法概述

希尔排序是对插入排序的一种改进，主要思想是通过将整个序列分成若干个子序列分别进行插入排序，从而使整个序列在排序时更加高效。

算法实现

#include <iostream>
#include <vector>

void shellSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

间复杂度

最优时间复杂度：O(n log n)
平均时间复杂度：O(n^(3/2))
最坏时间复杂度：O(n^2)

空间复杂度

O(1) （原地排序）

应用场景

希尔排序在一些较大的数据集中通常表现良好，因此在某些情况下成为插入排序的替代选择。

8. 计数排序（Counting Sort）

算法概述

计数排序是一种非比较排序算法，它通过计算每个元素出现的次数来确定它们在排序后应在数组中的位置。这种算法通常用于特定范围内的整数排序。

算法实现

#include <iostream>
#include <vector>

void countingSort(std::vector<int>& arr) {
    int n = arr.size();
    int maxVal = *max_element(arr.begin(), arr.end());
    std::vector<int> count(maxVal + 1, 0);

    // 统计每个元素的出现次数
    for (int i = 0; i < n; i++) {
        count[arr[i]]++;
    }

    // 重构排序后的数组
    int index = 0;
    for (int i = 0; i <= maxVal; i++) {
        while (count[i] > 0) {
            arr[index++] = i;
            count[i]--;
        }
    }
}

时间复杂度

O(n + k) （n是元素数量，k是元素范围）

空间复杂度

O(k) （需要额外的计数数组）

应用场景

计数排序适用于范围有限且数据量大的场景，例如排序0到100之间的整数。

9. 桶排序（Bucket Sort）

算法概述

桶排序是将数组划分成多个桶，分别对每个桶内的元素进行排序，最后再将排序后的桶合并成一个有序数组。

算法实现

#include <iostream>
#include <vector>
#include <algorithm>

void bucketSort(std::vector<int>& arr) {
    int n = arr.size();
    if (n <= 0) return;

    int maxVal = *max_element(arr.begin(), arr.end());
    int bucketCount = maxVal / 10 + 1;
    std::vector<std::vector<int>> buckets(bucketCount);

    // 将元素分配到桶中
    for (int i = 0; i < n; i++) {
        int bi = arr[i] / 10; // 将元素放入相应的桶
        buckets[bi].push_back(arr[i]);
    }

    // 对每个桶进行排序
    for (int i = 0; i < bucketCount; i++) {
        std::sort(buckets[i].begin(), buckets[i].end());
    }

    // 合并桶中的元素
    int index = 0;
    for (int i = 0; i < bucketCount; i++) {
        for (auto& num : buckets[i]) {
            arr[index++] = num;
        }
    }
}

时间复杂度

平均时间复杂度：O(n + k)（当桶平衡时）
最坏时间复杂度：O(n^2)（所有元素落入同一个桶）

空间复杂度

O(n + k)（桶的存储）

应用场景

桶排序适用于数据均匀分布的场景，例如对浮点数进行排序。

10. 基数排序（Radix Sort）

算法概述

基数排序是一种非比较排序算法，它按位对数据进行排序，通常针对正整数。基本思想是先对每个位进行排序，从最低位到最高位进行处理。

算法实现

#include <iostream>
#include <vector>

int getMax(const std::vector<int>& arr) {
    return *max_element(arr.begin(), arr.end());
}

void countingSortForRadix(std::vector<int>& arr, int exp) {
    int n = arr.size();
    std::vector<int> output(n); // 输出结果数组
    int count[10] = {0};

    // 统计每个基数的出现次数
    for (int i = 0; i < n; i++) {
        count[(arr[i] / exp) % 10]++;
    }

    // 更改count[i]，使其包含每个基数的实际位置
    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }

    // 构建输出数组
    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    // 将排序结果复制回原数组
    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}

void radixSort(std::vector<int>& arr) {
    int maxVal = getMax(arr);

    // 按位进行计数排序
    for (int exp = 1; maxVal / exp > 0; exp *= 10) {
        countingSortForRadix(arr, exp);
    }
}