经典排序算法(C语言、Java版)
排序
比较
分类
-
比较排序的时间复杂度的下界O(nlogn)
对于n个待排序元素，在未比较时，可能的正确结果有n!种。在经过一次比较后，其中两个元素的顺序被确定，所以可能的正确结果剩余n!/2种（确定之前两个元素的前后位置的情况是相同，确定之后相当于少了一半的可能性）。依次类推，直到经过m次比较，剩余可能性n!/(2m)种。直到n!/(2m)<=1时，结果只剩余一种。根据斯特灵公式，此时的比较次数m为o(nlogn)次。所以基于排序的比较算法，最优情况下，复杂度是O(nlogn)的。
源码
C版
/**
* @file Sort.cpp
* @author Sprinining (Sprinining@gmail.com)
* @brief 交换排序：冒泡排序、快速排序
* 选择排序：普通选择排序、堆排序
* 插入排序：直接插入排序、二分插入排序、希尔排序
* 归并排序：普通归并排序
* 分布排序：计数排序、桶排序、基数排序
* @version 0.1
* @date 2022-05-06
*
* @copyright Copyright (c) 2022
*
*/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int cmp(const void* a, const void* b) { return *(int*)(a) - *(int*)b; }
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
// a, b不能是同一个地址的东西，否则会把该地址清零
void swap2(int* a, int* b) {
*a = *a ^ *b;
*b = *a ^ *b;
*a = *a ^ *b;
}
void display(int* ary, int size) {
for (int i = 0; i < size; i++) {
printf("%d ", ary[i]);
}
puts("");
}
// 1.冒泡排序
void bubbleSort(int* array, int size) {
// 比较size-1轮
for (int i = 0; i < size - 1; i++) {
// 是否已经有序了
bool isSorted = true;
// 每一轮都会有个大元素移到后面
for (int j = 0; j < size - 1 - i; j++) {
// 将相邻的两个比较，大的移到后面
if (array[j] > array[j + 1]) {
// 有交换的说明没排好
isSorted = false;
swap(&array[j], &array[j + 1]);
}
}
if (isSorted == true) break;
}
display(array, size);
}
void quickSortRecursive(int* array, int left, int right) {
if (left >= right) return;
int i = left;
int j = right;
// 基准元素
int key = array[left];
// 分成两半，左边小于基准元素，右边大于基准元素
while (i < j) {
// 从右往左找第一个小于key的
while (i < j && array[j] >= key) {
j--;
}
// 与key交换
if (i < j) {
array[i] = array[j];
// array[j]不用立刻放入key，后面可能会有比key大的元素防止这
i++;
}
// 从左往右找第一个大于key的
while (i < j && array[i] <= key) {
i++;
}
// 与key交换
if (i < j) {
array[j] = array[i];
j--;
}
}
// 循环退出时i=j
array[i] = key;
quickSortRecursive(array, left, i - 1);
quickSortRecursive(array, i + 1, right);
}
// 2.快速排序
void quickSort(int* array, int size) {
quickSortRecursive(array, 0, size - 1);
display(array, size);
}
// 3.普通选择排序
void selectionSort(int* array, int size) {
// size-1轮
for (int i = 0; i < size - 1; i++) {
int minIndex = i;
// 从后面找更小的
for (int j = i + 1; j < size; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
// 确实有更小的
if (minIndex != i) {
swap(&array[i], &array[minIndex]);
}
}
display(array, size);
}
// 自顶向下调整堆顶（只有堆顶不符合堆的定义）
void adjustHeap(int* array, int currentIndex, int size) {
int temp = array[currentIndex];
int leftChildIndex = 2 * currentIndex + 1;
while (leftChildIndex <= (size - 1)) {
// 找更大点的子节点
if (leftChildIndex < (size - 1) &&
array[leftChildIndex] < array[leftChildIndex + 1]) {
leftChildIndex++;
}
// 更大的子节点都比 temp 小，那就不需要再往下调整了
if (array[leftChildIndex] <= temp) break;
// 与子节点交换
array[currentIndex] = array[leftChildIndex];
// 调整子节点往下的分支
currentIndex = leftChildIndex;
leftChildIndex = 2 * currentIndex + 1;
}
array[currentIndex] = temp;
}
// 4.堆排序（下标从0开始）
void heapSort(int* array, int size) {
// 从第一个非叶子节点开始，自底向上
for (int i = (size - 2) / 2; i >= 0; i--) {
adjustHeap(array, i, size);
}
printf("大顶堆：");
display(array, size);
// size-1轮
for (int i = 1; i < size; i++) {
swap(&array[0], &array[size - i]);
// 已经是堆了，在修改完堆顶后只需要对堆顶进行重定位
adjustHeap(array, 0, size - i);
}
display(array, size);
}
// 5.直接插入排序
void insertionSort(int* array, int size) {
// size-1轮
// [0, i-1]是有序序列
for (int i = 1; i < size; i++) {
// 待插入的元素
int temp = array[i];
// 插入已经有序的序列
// 从有序序列的末尾往前找第一个小于等于temp的
int j = i - 1;
while (j >= 0 && (array[j] > temp)) {
// 边找边把不符合的元素后移
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}
display(array, size);
}
// 6.二分插入排序
void binaryInsertionSort(int* array, int size) {
for (int i = 1; i < size; i++) {
int temp = array[i];
// 二分查找插入位置
int left = 0;
int right = i - 1;
int mid;
while (left <= right) {
mid = left + (right - left) / 2;
if (array[mid] >= temp) {
right = mid - 1;
} else {
left = mid + 1;
}
}
// 循环结束后left就是应该插入的下标
// 把下标从left到i-1的都往后移动一位
for (int j = i - 1; j >= left; j--) {
array[j + 1] = array[j];
}
array[left] = temp;
}
display(array, size);
}
// 7.希尔排序
void shellSort(int* array, int size) {
// 步长（让一个元素可以一次性地朝最终位置前进一大步）
int gap = size / 2;
while (gap > 0) {
// 间隔gap的分在同一组(共gap组，gap下标[0,
// gap-1]是这gap组每组的首个已排序元素)，进行普通的插入排序
for (int i = gap; i < size; i++) {
int temp = array[i];
int j = i - gap;
while (j >= 0 && array[j] > temp) {
array[j + gap] = array[j];
j -= gap;
}
array[j + gap] = temp;
}
printf("gap:%d\n", gap);
display(array, size);
gap = gap / 2;
}
}
// 分治-治
void mergeSort_conquer(int* array, int left, int mid, int right, int* temp) {
// [left, mid]和[mid+1, right]两个有序数组
int i = left;
int j = mid + 1;
int index = 0;
while (i <= mid && j <= right) {
if (array[i] < array[j]) {
temp[index++] = array[i++];
} else {
temp[index++] = array[j++];
}
}
// 剩余元素直接放入temp
while (i <= mid) {
temp[index++] = array[i++];
}
while (j <= right) {
temp[index++] = array[j++];
}
// 放回原数组
index = 0;
while (left <= right) {
array[left++] = temp[index++];
}
}
// 分治-分
void mergeSort_divide(int* array, int left, int right, int* temp) {
if (left >= right) return;
int mid = left + (right - left) / 2;
// 左边归并排序
mergeSort_divide(array, left, mid, temp);
// 右边归并排序
mergeSort_divide(array, mid + 1, right, temp);
// 合并两个有序序列
mergeSort_conquer(array, left, mid, right, temp);
}
// 8.普通归并排序
void mergeSort(int* array, int size) {
int* temp = (int*)malloc(sizeof(int) * size);
mergeSort_divide(array, 0, size - 1, temp);
display(array, size);
}
// TODO: 迭代版归并排序
// 9.计数排序(每个桶只存储单一键值) 0~10
void countingSort(int* array, int size) {
int* frequency = (int*)calloc(11, sizeof(int));
// frequency[i]表示统计i出现的次数
for (int i = 0; i < size; i++) {
frequency[array[i]]++;
}
display(frequency, 11);
// frequency[i]表示小于等于i的个数
for (int i = 1; i < 11; i++) {
frequency[i] += frequency[i - 1];
}
display(frequency, 11);
int* sorted = (int*)calloc(size, sizeof(int));
// 倒着遍历原数组，把原数组放在新数组正确的位置上
for (int i = size - 1; i >= 0; i--) {
// 有frequency[array[i]]个小于等于array[i]个元素
// 说明array[i]排在第frequency[array[i]]个位置，下标就是frequency[array[i]]-1
// 放好后frequency[array[i]]要自减
sorted[--frequency[array[i]]] = array[i];
printf("frequency:\t");
display(frequency, 11);
printf("sorted:\t\t");
display(sorted, size);
}
}
typedef struct {
int** bucket;
int row;
int column;
int* index;
} Bucket;
// 10.桶排序(每个桶存储一定范围的数值)
// 数要相对均匀分布，桶的个数也要合理设计(需要知道输入数据的上界和下界和分布情况)，桶排序是一种用空间换取时间的排序
void bucketSort(int* array, int size) {
Bucket* b = (Bucket*)malloc(sizeof(Bucket));
b->row = 5;
b->column = 3;
b->index = (int*)calloc(b->row, sizeof(int));
b->bucket = (int**)malloc(sizeof(int) * b->row);
for (int i = 0; i < b->row; i++) {
b->bucket[i] = (int*)malloc(sizeof(int) * b->column);
}
// 放入桶
for (int i = 0; i < size; i++) {
int index = array[i] / 10;
b->bucket[index][b->index[index]++] = array[i];
}
size = 0;
// 对每个桶进行排序（可用其他算法）
for (int i = 0; i < b->row; i++) {
qsort(b->bucket[i], b->column, sizeof(int), cmp);
for (int j = 0; j < b->column; j++) {
array[size++] = b->bucket[i][j];
}
}
display(array, size);
}
// 11.基数排序(根据键值的每位数字来分配桶)
void radixSort(int* array, int size) {
Bucket* b = (Bucket*)malloc(sizeof(Bucket));
b->row = 10;
b->column = 10;
b->index = (int*)calloc(b->row, sizeof(int));
// 临时存放按某一位排好序的序列
b->bucket = (int**)malloc(sizeof(int) * b->row);
for (int i = 0; i < b->row; i++) {
b->bucket[i] = (int*)malloc(sizeof(int) * b->column);
}
// 最大的数的位数为3
for (int i = 0; i < 3; i++) {
// 按某一位重新排序
for (int j = 0; j < size; j++) {
int index = (array[j] / (int)pow(10, i)) % 10;
b->bucket[index][b->index[index]++] = array[j];
}
// 放回原数组
int returnSize = 0;
for (int j = 0; j < b->row; j++) {
for (int k = 0; k < b->index[j]; k++) {
array[returnSize++] = b->bucket[j][k];
}
// 重置下标数组
b->index[j] = 0;
}
}
display(array, size);
}
void testSort() {
// int a[] = {1, 0, 7, 2, 10, 5, 2, 8, 6, 0};
// display(a, 10);
// bubbleSort(a, 10);
// quickSort(a, 10);
// selectionSort(a, 10);
// heapSort(a, 10);
// insertionSort(a, 10);
// binaryInsertionSort(a, 10);
// shellSort(a, 10);
// mergeSort(a, 10);
// countingSort(a, 10);
// int b[] = {1, 8, 7, 44, 42, 46, 38, 34, 33, 17, 15, 16, 27, 28, 24};
// display(b, 15);
// bucketSort(b, 15);
int c[] = {53, 3, 542, 748, 14, 77, 214, 154, 63, 616};
radixSort(c, 10);
}
- 双轴快排
void daulPivotQuickSortRecursive(int* array, int left, int right) {
if (left >= right) return;
int i = left;
int j = right;
int k = i + 1;
// 小于等于pivot1：区间A=[left, i]
// 大于等于pivot2：区间B=[j, right]
// 两者之间：区间C=[i+1, k-1]
// 待处理：区间D=[k, j-1]
// 对两个轴处理
if (array[left] > array[right]) {
swap(&array[left], &array[right]);
}
int pivot1 = array[left];
int pivot2 = array[right];
while (k < j) {
if (array[k] > pivot1 && array[k] < pivot2) {
k++;
} else if (array[k] <= pivot1) {
// 把C的首个元素与当前元素交换，首个元素还在C中
swap(&array[++i], &array[k++]);
} else if (array[k] >= pivot2) {
// 从右往左找第一个比pivot2小的元素
while (k < j && array[j] >= pivot2) {
j--;
}
// k不用自增，j也不用自减
swap(&array[k], &array[j]);
}
}
// 把轴移到该放的位置
swap(&array[left], &array[i]);
swap(&array[right], &array[j]);
// 对两个轴分出的三个区间进行递归调用
daulPivotQuickSortRecursive(array, left, i - 1);
daulPivotQuickSortRecursive(array, i + 1, j - 1);
daulPivotQuickSortRecursive(array, j + 1, right);
}
// 12.双轴快排
void daulPivotQuickSort(int* array, int size) {
daulPivotQuickSortRecursive(array, 0, size - 1);
display(array, size);
}
Java版
package sort;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Sort {
// 对数器
public static boolean check(int count) {
for (int i = 0; i < count; i++) {
if (!isArrayEqual())
return false;
}
return true;
}
public static boolean isArrayEqual() {
int size = (int) (Math.random() * 100);
int[] array = generateRandomArray(size);
int[] temp = Arrays.copyOf(array, array.length);
Arrays.sort(array);
// bubbleSort(temp);
// quickSort(temp);
// daulPivotQuickSort(temp);
// selectionSort(temp);
// heapSort(temp);
// insertionSort(temp);
// binaryInsertionSrot(temp);
// shellSort(temp);
// mergeSort(temp);
// countingSort(temp);
// bucketSort(temp);
radixSort(temp);
return Arrays.equals(array, temp);
}
// 数组元素范围: [0, 999]
public static int[] generateRandomArray(int size) {
int[] res = new int[size];
for (int i = 0; i < size; i++) {
res[i] = (int) (Math.random() * 1000);
}
return res;
}
public static void swap(int[] array, int a, int b) {
int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean isSorted = true;
for (int j = 1; j < array.length - i; j++) {
if (array[j - 1] > array[j]) {
swap(array, j - 1, j);
isSorted = false;
}
}
if (isSorted)
break;
}
}
public static void quickSort(int[] array) {
quickSortRecursive(array, 0, array.length - 1);
}
public static void quickSortRecursive(int[] array, int left, int right) {
if (left >= right)
return;
int i = left;
int j = right;
int pivot = array[left];
while (i < j) {
while (i < j && array[j] >= pivot) {
j--;
}
if (i < j) {
array[i] = array[j];
i++;
}
while (i < j && array[i] <= pivot) {
i++;
}
if (i < j) {
array[j] = array[i];
j--;
}
}
array[i] = pivot;
quickSortRecursive(array, left, i - 1);
quickSortRecursive(array, i + 1, right);
}
// 双轴快排
public static void daulPivotQuickSort(int[] array) {
daulPivotQuickSortRecursive(array, 0, array.length - 1);
}
public static void daulPivotQuickSortRecursive(int[] array, int left, int right) {
if (left >= right)
return;
int i = left;
int j = right;
int k = left + 1;
// A:[left, i]
// B:[i+1, k-1]
// C:[k, j-1]
// D:[j, right]
if (array[left] > array[right]) {
swap(array, left, right);
}
int pivot1 = array[left];
int pivot2 = array[right];
while (k < j) {
int temp = array[k];
if (temp > pivot1 && temp < pivot2) {
k++;
} else if (temp <= pivot1) {
swap(array, ++i, k++);
} else if (temp >= pivot2) {
while (k < j && array[j] >= pivot2) {
j--;
}
if (k < j) {
swap(array, k, j);
}
}
}
swap(array, left, i);
swap(array, j, right);
daulPivotQuickSortRecursive(array, left, i - 1);
daulPivotQuickSortRecursive(array, i + 1, j - 1);
daulPivotQuickSortRecursive(array, j + 1, right);
}
public static void selectionSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < array.length; j++) {
if (array[minIndex] > array[j]) {
minIndex = j;
}
}
if (minIndex != i) {
swap(array, i, minIndex);
}
}
}
public static void heapSort(int[] array) {
for (int i = (array.length - 2) / 2; i >= 0; i--) {
adjustHeap(array, i, array.length);
}
for (int i = 0; i < array.length - 1; i++) {
swap(array, 0, array.length - 1 - i);
adjustHeap(array, 0, array.length - 1 - i);
}
}
public static void adjustHeap(int[] array, int currentIndex, int len) {
int temp = array[currentIndex];
int leftChildIndex = 2 * currentIndex + 1;
while (leftChildIndex <= (len - 1)) {
if (leftChildIndex < (len - 1) && array[leftChildIndex] < array[leftChildIndex + 1]) {
leftChildIndex++;
}
if (array[leftChildIndex] <= temp)
break;
array[currentIndex] = array[leftChildIndex];
currentIndex = leftChildIndex;
leftChildIndex = 2 * currentIndex + 1;
}
array[currentIndex] = temp;
}
public static void insertionSort(int[] array) {
for (int i = 1; i < array.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;
}
}
public static void binaryInsertionSrot(int[] array) {
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int left = 0;
int right = i - 1;
int mid;
while (left <= right) {
mid = left + (right - left) / 2;
if (array[mid] >= temp) {
right = mid - 1;
} else {
left = mid + 1;
}
}
for (int j = i - 1; j >= left; j--) {
array[j + 1] = array[j];
}
array[left] = temp;
}
}
public static void shellSort(int[] array) {
int gap = array.length / 2;
while (gap > 0) {
for (int i = gap; i < array.length; i += gap) {
int temp = array[i];
int j = i - gap;
while (j >= 0 && array[j] > temp) {
array[j + gap] = array[j];
j -= gap;
}
array[j + gap] = temp;
}
gap /= 2;
}
}
public static void mergeSort(int[] array) {
int[] temp = new int[array.length];
mergeSort_divide(array, 0, array.length - 1, temp);
}
public static void mergeSort_divide(int[] array, int left, int right, int[] temp) {
if (left >= right)
return;
int mid = left + (right - left) / 2;
mergeSort_divide(array, left, mid, temp);
mergeSort_divide(array, mid + 1, right, temp);
mergeSort_conquer(array, left, mid, right, temp);
}
public static void mergeSort_conquer(int[] array, int left, int mid, int right, int[] temp) {
if (left >= right)
return;
int i = left;
int j = mid + 1;
int index = 0;
while ((i <= mid && j <= right)) {
if (array[i] <= array[j]) {
temp[index++] = array[i++];
} else {
temp[index++] = array[j++];
}
}
while (i <= mid) {
temp[index++] = array[i++];
}
while (j <= right) {
temp[index++] = array[j++];
}
index = 0;
while (left <= right) {
array[left++] = temp[index++];
}
}
public static void countingSort(int[] array) {
int[] frequency = new int[1000];
for (int j : array) {
frequency[j]++;
}
for (int i = 1; i < 1000; i++) {
frequency[i] += frequency[i - 1];
}
int[] sorted = new int[array.length];
for (int j : array) {
sorted[--frequency[j]] = j;
}
System.arraycopy(sorted, 0, array, 0, array.length);
}
public static void bucketSort(int[] array) {
// 数组元素范围: [0, 999]
// 十个桶: [0, 99], [100, 199] ...
List<List<Integer>> buckets = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
buckets.add(new ArrayList<>());
}
for (int i : array) {
int index = i / 100;
buckets.get(index).add(i);
}
// 每个桶可以用其他的排序方法
int index = 0;
for (List<Integer> bucket : buckets) {
Collections.sort(bucket);
for (Integer integer : bucket) {
array[index++] = integer;
}
}
}
public static void radixSort(int[] array) {
// 数组元素范围: [0, 999]
// 十进制要十个桶，[0, 9]
List<List<Integer>> buckets = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
buckets.add(new ArrayList<>());
}
// 3位要三次循环
for (int i = 0; i < 3; i++) {
for (int j : array) {
int index = (j / (int) Math.pow(10, i)) % 10;
buckets.get(index).add(j);
}
// 写回
int index = 0;
for (List<Integer> bucket : buckets) {
for (Integer integer : bucket) {
array[index++] = integer;
}
bucket.clear();
}
}
}
public static void main(String[] args) {
int[] a = {1, 0, 7, 2, 10, 5, 2, 8, 6, 0};
System.out.println(Arrays.toString(a));
// bubbleSort(a);
// quickSort(a);
// daulPivotQuickSort(a);
// selectionSort(a);
// heapSort(a);
// insertionSort(a);
// binaryInsertionSrot(a);
// shellSort(a);
// mergeSort(a);
// countingSort(a);
// bucketSort(a);
radixSort(a);
System.out.println(Arrays.toString(a));
System.out.println(check(10000));
}
}
C++版
void quickSort(vector<int> &array, int left, int right) {
if (left >= right) return;
int i = left;
int j = right;
int pivot = array[left];
while (i < j) {
while (i < j && pivot <= array[j]) {
j--;
}
if (i < j) {
array[i] = array[j];
i++;
}
while (i < j && pivot >= array[i]) {
i++;
}
if (i < j) {
array[j] = array[i];
j--;
}
}
array[i] = pivot;
quickSort(array, left, i - 1);
quickSort(array, i + 1, right);
}
// 自顶向下调整堆，len 是当前堆的大小，复杂度 O(logn)
void adjustHeap(vector<int> &array, int currentIndex, int len) {
// 要调整位置的元素
int temp = array[currentIndex];
// 左孩子下标
int leftChildIndex = 2 * currentIndex + 1;
// 自顶向下，调整到最后一个节点
while (leftChildIndex <= (len - 1)) {
// 把左右孩子中较大者的下标赋给 leftChildIndex
if (leftChildIndex < (len - 1)
&& (array[leftChildIndex] < array[leftChildIndex + 1]))
leftChildIndex++;
// 和当前元素比较大小，决定要不要调整堆
// 1. 不需要调整
if (array[leftChildIndex] <= temp) break;
// 2. 需要调整
array[currentIndex] = array[leftChildIndex];
currentIndex = leftChildIndex;
leftChildIndex = 2 * currentIndex + 1;
}
// 放在最终的位置
array[currentIndex] = temp;
}
// [[堆........]] -> [[堆....][升序列表...]] -> [[升序列表......]]
void headSort(vector<int> &array) {
// 1. 建堆：从最后一个非叶子节点开始向上调整每个节点，复杂度 O(n)
// 最后一个非叶子节点下标为 n/2-1，下标从0开始
for (int i = array.size() / 2 - 1; i >= 0; i--) {
adjustHeap(array, i, array.size());
}
// 2. n-1 轮排序:每次把大顶堆的堆顶移到末尾，并且堆的大小减一，最终形成升序列表
// 每次复杂度 O(logn)，共 n-1 次，整体复杂度 O(nlogn)
for (int len = array.size() - 1; len >= 1; len--) {
// 把大顶堆的堆顶与末尾元素交换
swap(array[0], array[len]);
// 调整交换后的堆顶
adjustHeap(array, 0, len);
}
}
- 基数排序
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
// 进制
static const int BASE = 10;
static const int MAXN = 50001;
static int help[MAXN];
static int cnts[BASE];
// 时间复杂度 O(n)
vector<int> sortArray(vector<int> &arr) {
if (arr.size() <= 1) return arr;
int n = arr.size();
int _min = arr[0];
// 找最小值
for (int i = 1; i < n; i++)
_min = min(_min, arr[i]);
int _max = 0;
// 先把整体减小，再找最大值
for (int i = 0; i < n; i++) {
arr[i] -= _min;
_max = max(_max, arr[i]);
}
// 根据最大值在 BASE 进制下的位数，决定基数排序做多少轮
radixSort(arr, n, bits(_max));
// 还原数组
for (int i = 0; i < n; i++)
arr[i] += _min;
return arr;
}
// 返回 number 在 BASE 进制下有几位
int bits(int number) {
int ans = 0;
while (number > 0) {
ans++;
number /= BASE;
}
return ans;
}
// arr 内要保证没有负数，bits 是 arr 中最大值在 BASE 进制下有几位
void radixSort(vector<int> &arr, int n, int bits) {
for (int offset = 1; bits > 0; offset *= BASE, bits--) {
fill(cnts, cnts + BASE, 0);
for (int i = 0; i < n; i++)
cnts[(arr[i] / offset) % BASE]++;
// 处理成前缀次数累加的形式
for (int i = 1; i < BASE; i++)
cnts[i] += cnts[i - 1];
// 直接定位到应该放到的位置
for (int i = n - 1; i >= 0; i--)
// 前缀数量分区的技巧
// 数字提取某一位的技巧
help[--cnts[(arr[i] / offset) % BASE]] = arr[i];
for (int i = 0; i < n; i++)
arr[i] = help[i];
}
}
};
int Solution::help[MAXN] = {0};
int Solution::cnts[Solution::BASE] = {0};
