排序算法【算法】

原创 已于 2025-05-30 14:36:38 修改 · 341 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

于 2023-11-18 15:01:40 首次发布
本文详细介绍了冒泡、选择、插入、快速、归并、堆、希尔、计数、桶和基数这十大排序算法。阐述了各算法的基本思想、动态演示、代码实现和算法性能，分析了它们的稳定性、适用场景及时间、空间复杂度，为排序算法的选择和使用提供了参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

一、冒泡排序（Bubble Sort）

  一种简单的排序算法，依次比较相邻元素，将较大（或较小）的元素逐渐交换到数组的末尾，直到整个数组有序。

1. 基本思想

  ① 从序列的第一个元素开始，依次比较相邻的两个元素。
  ② 如果当前元素大于后面的元素（按升序排序），则交换它们的位置。
  ③ 继续向后移动，重复上述比较和交换步骤，直到遍历到序列的最后一个元素。
  ④ 重复以上步骤，每次遍历都将待排序序列中最大的元素“冒泡”到末尾。
  ⑤ 经过 n − 1 n-1 n−1 次遍历后，待排序序列就会完全有序。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    for (int i = 0; i < length - 1; i++) {					// 外层循环，控制比较轮数，每轮确定一个最大值
        for (int j = 0; j < length - 1 - i; j++) {			// 内层循环，控制比较次数，每次比较相邻两个元素大小
            if (array[j] > array[j + 1]) {					// 如果前一个元素比后一个元素大，交换它们的位置
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  一种稳定的排序方法，冒泡排序思路简单，代码也简单，特别适合小数据的排序。但是，由于算法复杂度较高，在数据量大的时候不适合使用。时间复杂度为 【 O （ n 2 ）】 【O（n^2）】 【O（n2）】，在排序过程中仅需要一个元素的辅助空间用于元素的交换，空间复杂度为 【 O （ 1 ）】 【O（1）】 【O（1）】。

二、选择排序（Selection Sort）

  一种简单直观的排序算法，每次从未排序的部分中选择最小（或最大）的元素，并放到已排序部分的末尾，直到整个数组有序。

1. 基本思想

  ① 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  ② 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  ③ 重复上一步，直到所有元素均排序完毕。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    for (int i = 0; i < length - 1; i++) {					// 外层循环，控制比较轮数，每轮确定一个最小值
        int min_index = i; 									// 记录最小值下标
        for (int j = i + 1; j < length; j++)				// 内层循环，找到当前范围内最小值的下标
            if (array[j] < array[min_index])
                min_index = j;
        int temp = array[i];								// 将最小值与当前范围内第一个元素交换位置
        array[i] = array[min_index];
        array[min_index] = temp;
    }
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  用数组实现的选择排序是不稳定的，用链表实现的选择排序是稳定的。选择排序实现也比较简单，并且由于在各种情况下复杂度波动小，因此一般是优于冒泡排序的，适用于简单数据排序，时间复杂度为 【 O （ n 2 ）】 【O（n^2）】 【O（n2）】。

三、插入排序（Insertion Sort）

  一种简单直观的排序算法，将未排序的元素逐个插入到已排序部分的正确位置，直到整个数组有序。

1. 基本思想

  ① 把待排序的数组分成已排序和未排序两部分，初始的时候把第一个元素认为是已排好序的。
  ② 从第二个元素开始，在已排好序的子数组中寻找到该元素合适的位置并插入该位置。
  ③ 重复上述过程直到最后一个元素被插入有序子数组中。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    for (int i = 1; i < length; i++) {						// 外层循环，控制待插入元素的下标
        int temp = array[i]; 								// 记录待插入元素的值
        int j = i - 1;
        while (j >= 0 && array[j] > temp) {					// 内层循环，将待插入元素插入到已排序部分的合适位置
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = temp;
    }
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  一种稳定的排序方法，在数组较大的时候不适用，在数据比较少的时候，是一个不错的选择，一般做为快速排序的扩充，时间复杂度为 【 O （ n 2 ）】 【O（n^2）】 【O（n2）】。

四、快速排序（Quick Sort）

  一个知名度极高的排序算法，使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。通过选择一个基准元素，将数组分割成两部分，其中一部分小于基准元素，另一部分大于基准元素，然后对这两部分递归地进行快速排序。

1. 基本思想

  ① 从数列中挑出一个元素，称为 “基准”（pivot）。
  ② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
  ③ 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

void quick_sort(int array[], int left, int right) {
    if (left >= right)											// 递归结束条件，当left >= right时，数组已经有序
        return;
    int i = left, j = right, pivot = array[left]; 				// 设定基准值为左端元素
    while (i < j) {
        while (i < j && array[j] >= pivot)						// 从右往左找第一个小于基准值的元素
            j--;
        if (i < j)
            array[i++] = array[j];
        while (i < j && array[i] < pivot)						// 从左往右找第一个大于等于基准值的元素
            i++;
        if (i < j)
            array[j--] = array[i];
    }
    array[i] = pivot; 											// 将基准值插入到合适的位置
    quick_sort(array, left, i - 1); 							// 对左半部分进行快速排序
    quick_sort(array, i + 1, right); 							// 对右半部分进行快速排序
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    quick_sort(array, 0, length - 1); 						// 调用快速排序函数 
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  快速排序并不是稳定的，因为无法保证相等的数据按顺序被扫描到和按顺序存放。在大多数情况下都是适用的，尤其在数据量大的时候性能优越性更加明显。但是在必要的时候，需要考虑下优化以提高其在最坏情况下的性能，时间复杂度为 【 O （ n l o g n ）】 【O（n log n）】 【O（nlogn）】。

五、归并排序（Merge Sort）

  是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将数组分割成两部分，分别对这两部分进行归并排序，然后将两个有序子数组合并成一个有序数组。

1. 基本思想

  • 递归法（自上而下）
      ① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。
      ② 设定两个指针，最初位置分别为两个已经排序序列的起始位置。
      ③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。
      ④ 重复上一步，直到某一指针到达序列尾
      ⑤ 将另一序列剩下的所有元素直接复制到合并序列尾
  • 迭代法（自下而上）
      ① 将序列每相邻两个数字进行归并操作，形成 c e i l （ n / 2 ） ceil（n/2） ceil（n/2） 个序列，排序后每个序列包含两 / 一个元素。
      ② 若此时序列数不是 1 1 1 个则将上述序列再次归并，形成 c e i l （ n / 4 ） ceil（n/4） ceil（n/4）个序列，每个序列包含四 / 三个元素。
      ③ 重复上一步，直到所有元素排序完毕，即序列数为 1 1 1。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言，递归版：
#include <stdio.h>

void merge(int array[], int left, int mid, int right) {			// 归并函数
    int n1 = mid - left + 1; 									// 左半部分数组的长度
    int n2 = right - mid; 										// 右半部分数组的长度
    int L[n1], R[n2]; 											// 临时数组
    for (int i = 0; i < n1; i++)								// 将数据复制到临时数组L[]和R[]中
        L[i] = array[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = array[mid + 1 + j];
    int i = 0, j = 0, k = left;									// 归并临时数组到array[left..right]
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            array[k] = L[i];
            i++;
        } else {
            array[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {											// 将临时数组中剩余的元素复制到array[]
        array[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        array[k] = R[j];
        j++;
        k++;
    }
}

void merge_sort(int array[], int left, int right) {			// 归并排序函数
    if (left < right) {
        int mid = left + (right - left) / 2; 				// 计算中间索引
        merge_sort(array, left, mid); 						// 对左半部分进行归并排序
        merge_sort(array, mid + 1, right); 					// 对右半部分进行归并排序
        merge(array, left, mid, right); 					// 合并两个已排序的部分
    }
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    merge_sort(array, 0, length - 1); 						// 调用归并排序函数
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}
// C语言，迭代版：
#include <stdio.h>

void merge(int array[], int left, int mid, int right) {		// 归并函数
    int n1 = mid - left + 1;  								// 左半部分数组的长度
    int n2 = right - mid;     								// 右半部分数组的长度
    int L[n1], R[n2];         								// 临时数组
    for (int i = 0; i < n1; i++)							// 将数据复制到临时数组L[]和R[]中
        L[i] = array[left + i];
    for (int j = 0; j < n2; j++)
        R[j] = array[mid + 1 + j];
    int i = 0, j = 0, k = left;								// 归并临时数组到array[left..right]
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            array[k] = L[i];
            i++;
        } else {
            array[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {										// 将临时数组中剩余的元素复制到array[]
        array[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        array[k] = R[j];
        j++;
        k++;
    }
}

void merge_sort_iterative(int array[], int length) {		// 归并排序函数
    int current_size;  										// 当前子数组大小
    int left_start;    										// 左子数组起始索引
    for (current_size = 1; current_size <= length - 1; current_size = 2 * current_size) {		// 对不同大小的子数组进行合并
        for (left_start = 0; left_start < length - 1; left_start += 2 * current_size) {			// 每次合并的子数组对应的左起始索引
            int mid = left_start + current_size - 1;  											// 计算中间索引
            int right_end = left_start + 2 * current_size - 1;  								// 计算右子数组的结束索引
            if (right_end > length - 1)															// 确保右子数组的结束索引不超过数组长度
                right_end = length - 1;
            merge(array, left_start, mid, right_end);											// 合并两个子数组
        }
    }
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    merge_sort_iterative(array, length);  					// 调用迭代法归并排序函数
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  一种稳定的排序方法，在数据量比较大的时候也有较为出色的表现（效率上），时间复杂度为 【 O （ n l o g n ）】 【O（n log n）】 【O（nlogn）】但是，其空间复杂度为 【 O （ n ）】 【O（n）】 【O（n）】使得在数据量特别大的时候几乎不可接受。而且，考虑到有的机器内存本身就比较小，因此，采用归并排序一定要注意。

六、堆排序（Heap Sort）

  指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。将待排序的数组构建成一个堆（大顶堆或小顶堆），然后将堆顶元素与最后一个元素交换并移出堆，重复这个过程直到堆为空，得到有序数组。

1. 基本思想

  ① 最大堆调整（Max-Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点。
  ② 创建最大堆（Build-Max-Heap）：将堆所有数据重新排序，使其成为最大堆。
  ③ 堆排序（Heap-Sort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算 继续进行下面的讨论前，需要注意的一个问题是：数组都是 Zero-Based，这就意味着我们的堆数据结构模型要发生改变。

2. 动态演示

在这里插入图片描述
在这里插入图片描述

3. 代码实现

#include <stdio.h>

void swap(int arr[], int i, int j) {			// 交换数组中两个元素的位置
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

void maxHeapify(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) {							// 如果最大值不是当前节点，则将最大值上移至当前节点，并继续下沉
        swap(arr, i, largest);
        maxHeapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {				// 使用堆排序对数组进行排序
    for (int i = n / 2 - 1; i >= 0; i--)		// 构建最大堆
        maxHeapify(arr, n, i);
    for (int i = n - 1; i >= 0; i--) {			// 依次将最大值交换至数组末尾并调整堆结构
        swap(arr, 0, i);
        maxHeapify(arr, i, 0);
    }
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长度
    heapSort(arry, n);
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  一种不稳定的排序方法，在建立堆和调整堆的过程中会产生比较大的开销，在元素少的时候并不适用。但是，在元素比较多的情况下，是不错的一个选择，时间复杂度为 【 O （ n l o g n ）】 【O（n log n）】 【O（nlogn）】

七、希尔排序（Shell Sort）

  也称递减增量排序算法，是插入排序的一种更高效的改进版本。将数组按照一定的间隔分成多个子序列，对每个子序列进行插入排序，然后逐渐减小间隔直至为1，最后进行一次完整的插入排序。

1. 基本思想

  ① 选择一个增量序列 t 1 ， t 2 ， … ， t k t_1，t_2，…，t_k t1​，t2​，…，tk​，其中 t i > t j ， t k = 1 t_i > t_j，t_k = 1 ti​>tj​，tk​=1
  ② 按增量序列个数 k k k，对序列进行 k k k 趟排序；
  ③ 每趟排序，根据对应的增量 t i t_i ti​，将待排序列分割成若干长度为 m m m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 1 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  希尔排序的增量数列可以任取，需要的唯一条件是最后一个一定为 1 1 1（因为要保证按 1 1 1 有序）。但是，不同的数列选取会对算法的性能造成极大的影响。

2. 动态演示

在这里插入图片描述
在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

void shell_sort(int array[], int length) {
    for (int gap = length / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < length; i++) {				 				// 对每个子数组进行插入排序
            int temp = array[i];
            int j;
            for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {		// 插入排序
                array[j] = array[j - gap];
            }
            array[j] = temp;
        }
    }
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长
    shell_sort(array, length);  							// 调用希尔排序函数
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  不是一个稳定的算法，适用于中小型规模的数据，时间复杂度为 【 O （ n l o g n ）】 【O（n log n）】 【O（nlogn）】。

八、计数排序（Counting Sort）

  不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。统计数组中每个元素的出现次数，然后根据元素的大小依次将元素放入正确的位置，得到有序数组。

1. 基本思想

  ① 找出待排序的数组中最大和最小的元素；
  ② 统计数组中每个值为 i i i 的元素出现的次数，存入数组 C C C 的第 i i i 项；
  ③ 对所有的计数累加（从 C C C 中的第一个元素开始，每一项和前一项相加）；
  ④ 反向填充目标数组：将每个元素i放在新数组的第 C [ i ] C[i] C[i] 项，每放一个元素就将 C [ i ] C[i] C[i] 减去 1 1 1。

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>

void countingSort(int arr[], int n) {			// 使用计数排序对数组进行排序
    int max = arr[0];							// 查找数组中的最大值
    for (int i = 1; i < n; i++)
        if (arr[i] > max)
            max = arr[i];
    int count[max + 1];							// 创建计数数组，用于存储每个数字出现的次数
    for (int i = 0; i <= max; i++) {
        count[i] = 0;
    }
    for (int i = 0; i < n; i++)					// 统计每个数字出现的次数
        count[arr[i]]++;
    int output[n];								// 根据计数数组重构排序后的数组
    int index = 0;
    for (int i = 0; i <= max; i++) {
        while (count[i] > 0) {
            output[index] = i;
            count[i]--;
            index++;
        }
    }
    for (int i = 0; i < n; i++)					// 将排序后的数组复制回原始数组
        arr[i] = output[i];
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长
    countingSort(array, n);
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  是一个稳定的算法，排序目标要能够映射到整数域，其最大值最小值应当容易辨别。计数排序需要占用大量空间，它比较适用于数据比较集中的情况，时间复杂度为 【 O （ k + n ）】 【O（k + n）】 【O（k+n）】， k k k 是待排序序列中的最大值， n n n 是序列的长度

九、桶排序（Bucket Sort）

  是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。将待排序的元素划分到若干个有序的桶中，对每个桶内的元素进行排序，然后按照桶的顺序依次将元素取出，得到有序数组。

1. 基本思想

  ① 找出待排序数组中的最大值、最小值
  ② 使用动态数组 A r r a y L i s t ArrayList ArrayList 作为桶，桶里放的元素也用 A r r a y L i s t ArrayList ArrayList 存储，桶的数量为： （ m a x − m i n ） / a r r . l e n g t h + 1 （max-min）/ arr.length + 1 （max−min）/arr.length+1
  ③ 遍历数组 a r r arr arr，计算每个元素放的桶
  ④ 每个桶各自排序
  ⑤ 遍历桶数组，把排序好的元素放进输出数组

2. 动态演示

在这里插入图片描述

3. 代码实现

// C语言：
#include <stdio.h>
#include <stdlib.h>

typedef struct bucket {			// 桶结构体定义
    int count; 					// 桶内元素数量
    int* values; 				// 桶内元素数组
} bucket_t;

void bucketSort(int arr[], int n) {		// 使用桶排序对数组进行排序
    bucket_t buckets[n];				// 创建桶数组
    for (int i = 0; i < n; i++) {
        buckets[i].count = 0;
        buckets[i].values = NULL;
    }
    for (int i = 0; i < n; i++) {		 // 将每个元素分配到对应的桶中
        int index = (float)n * arr[i] / (INT_MAX + 1LL);
        if (buckets[index].values == NULL) {
            buckets[index].values = malloc(sizeof(int));
        } else {
            int* tmp = realloc(buckets[index].values, (buckets[index].count + 1) * sizeof(int));
            if (tmp != NULL) {
                buckets[index].values = tmp;
            } else {
                printf("内存分配失败！\n");
                exit(1);
            }
        }
        buckets[index].values[buckets[index].count++] = arr[i];
    }
    for (int i = 0; i < n; i++) {			// 对每个非空桶进行插入排序
        if (buckets[i].count > 0) {
            for (int j = 1; j < buckets[i].count; j++) {
                int value = buckets[i].values[j];
                int hole = j;
                while (hole > 0 && buckets[i].values[hole - 1] > value) {
                    buckets[i].values[hole] = buckets[i].values[hole - 1];
                    hole--;
                }
                buckets[i].values[hole] = value;
            }
        }
    }
    int index = 0;					// 将每个桶中的元素复制回原数组
    for (int i = 0; i < n; i++) {
        if (buckets[i].count > 0) {
            for (int j = 0; j < buckets[i].count; j++)
                arr[index++] = buckets[i].values[j];
            free(buckets[i].values);
        }
    }
}

int main(void) {
    int array[] = {6, 48, 96, 24, 66, 150, 8, 24, 288}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长
    bucketSort(arry, n);
    for (int i = 0; i < length; i++)						// 输出排序后的结果
        printf("%d ", array[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  是一个稳定的算法，桶排序可用于最大最小值相差较大的数据情况，但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中，时间复杂度为 【 O （ n + m ）】 【O（n + m）】 【O（n+m）】， n n n 是序列的长度， m m m 是桶的数量。

十、基数排序（Radix Sort）

  是桶排序的扩展，根据元素的位数进行排序，先按个位排序，再按十位排序，以此类推，直到最高位排序完成，得到有序数组。

1. 基本思想

  ① 取得数组中的最大数，并取得位数；
  ② a r r arr arr 为原始数组，从最低位开始取每个位组成 r a d i x radix radix 数组；
  ③ 对 r a d i x radix radix 进行计数排序（利用计数排序适用于小范围数的特点）；

2. 动态演示

在这里插入图片描述

3. 代码实现

#include <stdio.h>

int getMax(int arr[], int n) {			// 获取数组中最大的元素
    int max = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] > max)
            max = arr[i];
    return max;
}

void countingSort(int arr[], int n, int exp) {			// 使用计数排序根据指定位数对数组进行排序
    int output[n]; 										// 存储排序结果的临时数组
    int count[10] = {0}; 								// 计数数组，用于存储每个数字出现的次数
    for (int i = 0; i < n; i++)							// 统计每个数字出现的次数
        count[(arr[i] / exp) % 10]++;
    for (int i = 1; i < 10; i++)						// 将count数组转换为每个数字应该在输出数组中的位置索引
        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(int arr[], int n) {					// 使用基数排序对数组进行排序
    int max = getMax(arr, n);				 		// 获取数组中的最大元素  
    for (int exp = 1; max / exp > 0; exp *= 10)		// 对每个数字的每一位进行计数排序
        countingSort(arr, n, exp);
}

int main(void) {
    int array[] = {36, 48, 96, 24, 66, 50, 8, 24, 88}; 		// 待排序数组
    int length = sizeof(array) / sizeof(array[0]); 			// 数组长
    radixSort(arr, n);
    for (int i = 0; i < n; i++)								// 输出排序后的结果
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

4. 算法性能

  是一种稳定的排序，每一轮映射和收集操作，都保持从左到右的顺序进行，如果出现相同的元素，则保持他们在原始数组中的顺序。要求较高，元素必须是整数，整数时长度 10 W 10W 10W 以上，最大值 100 W 100W 100W 以下效率较好，但是基数排序比其他排序好在可以适用字符串，或者其他需要根据多个条件进行排序的场景，时间复杂度为 O （ d × （ n + k ）） O（d ×（n+k）） O（d×（n+k））， n n n 是待排序序列的长度， k k k 是基数的范围， d d d 是待排序序列的最大位数。

五、排序算法总结

在这里插入图片描述

排序算法动态图解！一看就懂
03-30
收集了几乎全部的排序算法的动图图解，更有堆排序算法逐帧截图！绝对让你一看就懂！
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
排序算法群星豪华大汇演
qiudesuo的专栏
10-30 489
排序算法群星豪华大汇演   排序算法相对简单些，但是由于它的家族比较庞大——这也许是因为简单的缘故吧，网上整理排序算法实在太多了，什么经典排序算法，八大排序算法总结，精通八大排序算法等枚不胜举，当然这里也不例外，同样是整理，同样是学习的过程。 之前一些排序算法总是说不清楚（作者自己的感受），这倒不是因为太难，作者觉得是因为排序算法太繁复了（一些算法之间的区别不是很明显），那也没有他法，只...
【数据结构】 排序算法
最新发布
qq_56251766的博客
07-01 958
数据结构中的排序算法及实现
各种排序算法
chenj_freedom的技术点滴
05-17 674
说明： 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。...
排序算法
喂_balabala
07-30 158
https://www.jianshu.com/p/40366c82c69f @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); int[] ran...
十种常见的排序算法
weixin_30920091的博客
08-03 4215
1.常见算法分类 十种常见排序算法一般分为以下几种： （1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）； （2）线性时间非比较类排序：计数排序、基数排序和桶排序。 总结： （1）在比较类排序中，归并排序号称最快，其次是快速排序和...
最快的排序算法 算法数据结构
04-07
"最快的排序算法 算法数据结构" 该资源主要讨论了一个最快的排序算法，它的时间复杂度达到O(n log log n)，是目前世界上最快的排序算法之一。该算法的实现主要基于基数排序，并且混合使用了多种排序方法来达到最快...
最快的排序算法 计算机最快的算法-史上14个最快速算法：孩子的计算能力爆表！大脑堪比计算机！...，排序算法数据结构
04-07
在计算机科学领域中，排序算法是一种基本的算法，它可以将数据按照一定的顺序排列，以便更好地存储、检索和处理数据。排序算法的速度和效率对程序的性能有着至关重要的影响。 1.冒泡排序算法 冒泡排序算法是一种...
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
# 排序算法
m0_72829651的博客
04-27 716
通过重复遍历列表，比较相邻元素并交换顺序错误的元素，直到没有需要交换的元素为止。分治法策略：选择基准元素，将数组分为小于基准和大于基准的两部分，递归处理子数组。利用最大堆的性质，将堆顶元素（最大值）与末尾元素交换，重复调整堆结构。维护一个有序区，逐个将未排序区的元素插入到有序区的正确位置。分治法策略：将数组递归分为单元素子数组，合并时保持有序。每次从未排序区选择最小元素，放到已排序区的末尾。
十大经典排序算法（附程序）
u013247002的博客
12-05 1067
转自https://www.cnblogs.com/onepixel/articles/7674659.html 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的...
还在为面试发愁吗？这里有动态图解十大经典排序算法。
凡是过往，皆为序章
04-30 325
之前的一篇几张动态图清晰展示常用数据结构及其设计原理发出来之后反响不错，这次来个动图排序算法大全。数据结构与算法，算是齐了！ 本文将采取动态图 + 文字描述 + Java代码实现来讲解以下十大排序算法： 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 计数排序 桶排序 基数排序...
排序算法(详解)
2303_77982246的博客
12-14 2446
排序在日常生活中十分重要，购物平台上商品的排序，各国高校等级的排序......可以说，现代生活中已经离不开排序了；因此学好排序算法至关重要，本篇文章就来讲讲常见的排序算法排序的种类非常多，按照种类划分，有插入排序，选择排序，交换排序......，而每种排序中又分多种排序，下图是常见的排序算法。
各种排序算法的动图实现
~星空任我游~
07-29 1314
什么都不介绍，自己去对号入座，填好每一步的问题！！！ 原文链接：https://blog.csdn.net/wfq784967698/article/details/79551476，里面有较为详细的讲解，不熟悉的可以去看看。 1. 排序名称： 基本思路： 算法过程： 代码： 时间/空间复杂度： 稳定性： 2. 排序名称： 基本思路： 算法过程： 代码： 时间/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值