排序算法详解

最新推荐文章于 2024-07-07 12:10:24 发布

白夜_KK

最新推荐文章于 2024-07-07 12:10:24 发布

阅读量88

点赞数 2

分类专栏：数据结构文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/sunburst5227/article/details/133847136

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

最近做排序的选择题正确率有点低，所以写一些东西整理一下知识，如果有不正确的地方欢迎大家指正。
动画演示网站

1、冒泡排序（Bubble Sort）

基本思想

冒泡排序是一种简单的排序算法，它重复地遍历待排序的列表，比较每一对相邻的元素，如果它们的顺序错误就交换它们。遍历列表的工作是重复地进行直到没有再需要交换，也就是说该列表已经排序完成。

算法步骤

遍历数组：从第一个元素开始，对相邻元素进行比较。
元素交换：如果第一个元素大于第二个元素，则交换它们。
重复步骤：继续执行步骤1和2，直到整个数组排序完毕。

C语言代码实现

#include <stdio.h>
#include <stdbool.h>

// 交换两个整数的函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    bool swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
                swapped = true;
            }
        }
        // 如果在内部循环中没有发生任何交换，那么数组已经是有序的
        if (!swapped) {
            break;
        }
    }
}

时间复杂度

最好情况：O(n)（当数组已经是有序的）
平均情况：O( $n^2$ )
最坏情况：O( $n^2$ )

空间复杂度

空间复杂度：O(1)

稳定性

稳定性：稳定

优缺点

优点：
- 简单易于实现。
- 稳定排序。
- 在数组已经部分有序的情况下效率较高。
缺点：
- 平均和最坏情况的时间复杂度都是 (O(n^2))，不适合大数据量。

2、选择排序（Selection Sort）

基本思想

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

算法步骤

找最小值：在未排序的序列中找到最小（或最大）元素。
元素交换：将找到的最小（或最大）元素与序列的第一个元素交换。
重复步骤：对剩下的未排序元素重复步骤1和2。

C语言代码实现

#include <stdio.h>

// 交换两个整数的函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 选择排序函数
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        swap(&arr[min_idx], &arr[i]);
    }
}

时间复杂度

最好情况：O( $n^2$ )
平均情况：O( $n^2$ )
最坏情况：O( $n^2$ )

空间复杂度

空间复杂度：O(1)

稳定性

稳定性：不稳定

优缺点

优点：
- 实现简单。
- 空间复杂度低。
缺点：
- 时间复杂度始终为 O( $n^2$ )，不适用于大数据量。
- 不是稳定排序。

3、插入排序（Insertion Sort）

基本思想

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法步骤

从第一个元素开始：这个元素可以认为已经被排序。
移除下一个元素：在已排序的元素序列中从后向前扫描。
找到相应位置：将新元素与已排序元素从后向前比较，找到合适的位置。
元素移动：将新元素插入到该位置后。

C语言代码实现

#include <stdio.h>

// 插入排序函数
void insertionSort(int arr[], int n) {
    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];  // 如果 arr[j] > key，就把 arr[j] 向后移动一位
            j--;
        }
        
        arr[j + 1] = key;  // 插入 key 到正确位置
    }
}

时间复杂度

最好情况：O(n)（当数组已经是有序的）
平均情况：O( $n^2$ )
最坏情况：O( $n^2$ )

空间复杂度

空间复杂度：O(1)

稳定性

稳定性：稳定

优缺点

优点：
- 实现简单。
- 稳定排序。
- 在数组部分有序的情况下效率较高。
缺点：
- 平均和最坏情况的时间复杂度为 O( $n^2$ )，不适用于大数据量。

4、快速排序（Quick Sort）

基本思想

快速排序是一种“分治”（Divide and Conquer）算法。它通过选择一个“基准”（pivot）元素，并以此元素为界将数组分为两个子数组：一个包含小于或等于基准元素的所有元素，另一个包含大于基准元素的所有元素。然后，对这两个子数组递归地进行快速排序。

算法步骤

选择基准元素：可以选择第一个元素、最后一个元素、中间元素或者使用其他方法。
划分子数组：将所有小于基准的元素移动到基准的左侧，所有大于基准的元素移动到右侧。
递归排序：对左右两个子数组递归地进行快速排序。

C语言代码实现

#include <stdio.h>

// 交换两个整数的函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 划分函数
int partition(int arr[], int low, int high) {
    // 选择基准元素，这里选择最后一个元素
    int pivot = arr[high];
    
    // 初始化小于基准的元素的索引
    int i = (low - 1);

    // 遍历数组，将小于基准的元素移到左侧
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    
    // 将基准元素放到正确的位置
    swap(&arr[i + 1], &arr[high]);
    
    return (i + 1);
}

// 快速排序函数
void quickSort(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 l o g n$ )
平均情况：O( $n l o g n$ )
最坏情况：O( $n^2$ )

空间复杂度

空间复杂度：O( $l o g n$ )

稳定性

稳定性：不稳定

优缺点

优点：
- 在平均和最好情况下，排序速度快。
- 空间复杂度相对较低。
缺点：
- 不稳定。
- 在最坏情况下，时间复杂度较高。

5、归并排序（Merge Sort）

基本思想

归并排序是一种“分治”（Divide and Conquer）算法。其基本思想是将原始数组切分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，以此类推，最终得到一个有序数组。

算法步骤

分解：将当前区间一分为二。
解决：递归地对每个区间进行归并排序。
合并：将两个有序区间合并为一个有序区间。

C语言代码实现

#include <stdio.h>

// 合并两个有序数组的函数
void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    // 创建临时数组
    int L[n1], R[n2];

    // 复制数据到临时数组 L[] 和 R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    // 合并临时数组回 arr[l..r]
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // 复制 L[] 的剩余元素
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    // 复制 R[] 的剩余元素
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

// 归并排序函数
void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;

        // 对两个子数组进行排序
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        // 合并子数组
        merge(arr, l, m, r);
    }
}

时间复杂度

最好情况：O( $n l o g n$ )
平均情况：O( $n l o g n$ )
最坏情况：O( $n l o g n$ )

空间复杂度

空间复杂度：O(n)

稳定性

稳定性：稳定

优缺点

优点：
- 稳定排序。
- 时间复杂度始终为 O( $n l o g n$ ) 。
缺点：
- 需要额外的存储空间。

6、堆排序（Heap Sort）

基本思想

堆排序是一种基于二叉堆（特殊的树形数据结构）的比较排序算法。它首先构建一个最大堆或最小堆，然后从堆中逐个提取最大或最小元素以获得排序结果。

算法步骤

构建堆：将输入数据构建为一个最大堆或最小堆。
提取元素：将堆顶元素与最后一个元素交换，然后从堆中移除它。
堆调整：调整堆以恢复堆的性质。
重复步骤：重复步骤 2 和 3，直到堆变为空。

C语言代码实现

#include <stdio.h>

// 堆调整函数
void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest])
        largest = l;

    if (r < n && arr[r] > arr[largest])
        largest = r;

    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;

        heapify(arr, n, largest);
    }
}

// 堆排序函数
void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        heapify(arr, i, 0);
    }
}

时间复杂度

最好情况：O( $n l o g n$ )
平均情况：O( $n l o g n$ )
最坏情况：O( $n l o g n$ )

空间复杂度

空间复杂度：O(1)

稳定性

稳定性：不稳定

优缺点

优点：
- 在平均和最坏情况下，都有较好的时间复杂度。
- 是原地排序，不需要额外的存储空间。
缺点：
- 不是稳定排序。
- 对于小数据集，其常数因子可能会使其不如其他 O( $n l o g n$ ) 算法快。

7、基数排序（Radix Sort）

基本思想

基数排序是一种非比较排序算法，适用于整数或者字符串等数据类型。它的基本思想是逐个位数地对数字进行排序。

算法步骤

找出最大数的位数：确定排序所需的遍历次数。
按位数排序：从最低有效位（Least Significant Digit, LSD）或最高有效位（Most Significant Digit, MSD）开始，对每一位进行排序。

C语言代码实现

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 用于按照指定位数进行排序的函数
void countingSortByDigit(int arr[], int n, int digit) {
    int output[n];
    int count[10] = {0};

    for (int i = 0; i < n; i++) {
        int d = (arr[i] / (int)pow(10, digit)) % 10;
        count[d]++;
    }

    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }

    for (int i = n - 1; i >= 0; i--) {
        int d = (arr[i] / (int)pow(10, digit)) % 10;
        output[count[d] - 1] = arr[i];
        count[d]--;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}

// 基数排序函数
void radixSort(int arr[], int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }

    int digits = log10(max) + 1;

    for (int i = 0; i < digits; i++) {
        countingSortByDigit(arr, n, i);
    }
}

时间复杂度

最好情况：O( $d * (n + k)$ )
平均情况：O( $d * (n + k)$ )
最坏情况：O( $d * (n + k)$ )
d是最大值的位数，k是进制

空间复杂度

空间复杂度：O( $n + k$ )

稳定性

稳定性：稳定

优缺点

优点：
- 当 k 相对较小时，效率高。
- 稳定排序。
缺点：
- 当 k 非常大时，时间复杂度和空间复杂度都会增加。
- 仅适用于数字和某些特定类型的字符串。

8、希尔排序（Shell Sort）

基本思想

希尔排序是插入排序的一种更高效的改进版本，也称为“缩小增量排序”。它通过比较相距一定间隔的元素来工作，各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。

算法步骤

选择增量：选择一个增量序列，一般以 (n/2) 为首个增量。
按增量分组：按照选定的增量将数组元素分成多个子序列。
插入排序：对每个子序列进行插入排序。
减小增量：减小增量并重复步骤 2 和 3，直到增量为 1。

C语言代码实现

#include <stdio.h>

void shellSort(int arr[], int n) {
    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 l o g n$ )
平均情况：取决于增量序列，一般为 O( $n^{1.3}$ )
最坏情况：O( $n^2$ )

空间复杂度

空间复杂度：O(1)

稳定性

稳定性：不稳定

优缺点

优点：
- 相对于插入排序有更好的时间复杂度。
- 是原地排序，不需要额外的存储空间。
缺点：
- 不是稳定排序。
- 时间复杂度依赖于选取的增量序列。

时空复杂度汇总

排序算法的时空复杂度及稳定性汇总

排序算法	最好情况时间复杂度	平均情况时间复杂度	最坏情况时间复杂度	空间复杂度	是否稳定
选择排序	O( $n^2$ )	O( $n^2$ )	O( $n^2$ )	O(1)	不稳定
冒泡排序	O( $n$ )	O( $n^2$ )	O( $n^2$ )	O(1)	稳定
插入排序	O( $n$ )	O( $n^2$ )	O( $n^2$ )	O(1)	稳定
快速排序	O( $\log n$ )	O( $\log n$ )	O( $n^2$ )	O( $\log n$ )	不稳定
归并排序	O( $\log n$ )	O( $\log n$ )	O( $\log n$ )	O( $n$ )	稳定
堆排序	O( $\log n$ )	O( $\log n$ )	O( $\log n$ )	O(1)	不稳定
基数排序	O( $d * (n + k)$ )	O( $d * (n + k)$ )	O( $d * (n + k)$ )	O( $n + k$ )	稳定
希尔排序	O( $\log n$ )	O( $n^{1.3}$ )	O( $n^2$ )	O(1)	不稳定