经典排序算法(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};
经典排序算法(C语言、Java版)的更多相关文章
- 常见排序算法题（java版）
常见排序算法题(java版) //插入排序: package org.rut.util.algorithm.support; import org.rut.util.algorithm.Sor ...
- 常见排序算法总结（java版）
一.冒泡排序 1.原理:相邻元素两两比较,大的往后放.第一次完毕,最大值在最大索引处. 即使用相邻的两个元素一次比价,依次将最大的数放到最后. 2.代码: public static void bub ...
- 动画展现十大经典排序算法（附Java代码）
0.算法概述 0.1 算法分类 十种常见排序算法可以分为两大类: 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序. 非比较类排序: ...
- 一文搞定十大经典排序算法（Java实现）
本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一 ...
- 十大经典排序算法（java实现、配图解，附源码)
前言: 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备,以及个人的心得体会,汇集成本篇文章,作为自己对排序算法理解的总结与笔记. 内容主要是关于十大经典排序算法的简介.原理.动静 ...
- Java实现经典七大经典排序算法
利用Java语言实现七大经典排序算法:冒泡排序.选择排序.插入排序.希尔排序.堆排序.归并排序以及快速排序. 分类 类别 算法 插入排序类 插入排序.希尔排序 选择排序类 选择排序.堆排序 交换排序类 ...
- 【最全】经典排序算法（C语言）
算法复杂度比较: 算法分类 一.直接插入排序 一个插入排序是另一种简单排序,它的思路是:每次从未排好的序列中选出第一个元素插入到已排好的序列中. 它的算法步骤可以大致归纳如下: 从未排好的序列中拿出首 ...
- 十大经典排序算法最强总结（含JAVA代码实现）(转)
十大经典排序算法最强总结(含JAVA代码实现) 最近几天在研究排序算法,看了很多博客,发现网上有的文章中对排序算法解释的并不是很透彻,而且有很多代码都是错误的,例如有的文章中在“桶排序”算法中对每 ...
- 十大经典排序算法最强总结（含Java、Python码实现）
引言 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面 ...
- 经典排序算法之-----选择排序（Java实现）
其他的经典排序算法链接地址:https://blog.csdn.net/weixin_43304253/article/details/121209905 选择排序思想: 思路: 1.从整个数据中挑选 ...
随机推荐
- 如何在vscode中支持python的annotation（注解，type checking）——通过设置pylance参数实现python注解的type checking
pylance是vscode的python官方插件的捆绑体,如何在vscode中安装python插件这里不介绍了.pylance的默认设置是不支持python的annotation的,需要我们手动设置 ...
- 手把手教你掌握SeaTunnel k8s运行Zeta引擎本地模式的技巧
转载自小虾米0.0 导读:随着Kubernetes的普及和发展,越来越多的企业和团队开始使用Kubernetes来管理和部署应用程序.然而,Kubernetes的默认工作方式可能不是最佳的选择,尤其是 ...
- java关于数组的复制，反转、查找
一.数组的赋值: arr2=arr1;对于该赋值而言,地址值一样,所以arr1会随着arr2的变化而变化.这不能称作数组的复制,因为只是把地址赋过去了.地址一样,指向的是堆空间中唯一的数组实体(数值) ...
- 【全】CSS动画大全之其他【火影忍者动态背景】
效果预览 代码 <!DOCTYPE html> <html> <head> <head> <meta charset="utf-8&qu ...
- .NET MAUI 布局
先看一段代码的效果: <?xml version="1.0" encoding="utf-8" ?> <ContentPage xmlns=& ...
- flex数据绑定
1 .方法绑定 [Bindable(event="myFlagChanged")] private function isEnabled():String { if (myF ...
- 如何诱导AI犯罪-提示词注入
我们用到的大模型基本把政治类信息.犯罪相关信息都已屏蔽.但是,黑客依旧可以使用提示词诱导和提示词注入的方式对大模型进行攻击. 1.提示词诱导 如果直接让AI提供犯罪过程,AI会直接拒绝.虽然AI对于大 ...
- vs2022不安装docker desktop可以打包镜像吗
vs2022开发的项目可以直接打包镜像到 linux主机. idea 可以使用docker插件直接打包镜像到linux,我想vs2022也可以,于是开始摸索 官网只说支持docker desktop ...
- 使用 Microsoft Remote Desktop 远程连接 Windows
Windows 使用 Microsoft 帐户登录 远程连接时使用的用户名和密码是你的 Microsoft 帐户的用户名和密码 Windows 使用本地帐户登录 远程连接时使用的用户名和密码是你本地登 ...
- FFmpeg开发笔记（五十二）移动端的国产视频播放器GSYVideoPlayer
GSYVideoPlayer是一个国产的移动端视频播放器,它采用了IJKPlayer.Media3(EXOPlayer).MediaPlayer.AliPlayer等四种播放器内核,支持弹幕.滤镜. ...