冒泡排序(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]);
}
}
}
}
选择排序(Selection Sort):
void selectionSort(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
int minIndex = i;
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
std::swap(arr[i], arr[minIndex]);
}
}
插入排序(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;
}
}
快速排序(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 pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
归并排序(Merge Sort):
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int* L = new int[n1];
int* R = new int[n2];
for (int i = 0; i < n1; i++) {
L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
delete[] L;
delete[] R;
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
堆排序(Heap Sort):
void heapify(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) {
std::swap(arr[i], arr[largest]);
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--) {
std::swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
希尔排序(Shell Sort):
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;
}
}
}
计数排序(Counting Sort):
void countingSort(int arr[], int n) {
int maxVal = *std::max_element(arr, arr + n);
int* count = new int[maxVal + 1];
std::memset(count, 0, sizeof(int) * (maxVal + 1));
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
for (int i = 1; i <= maxVal; i++) {
count[i] += count[i - 1];
}
int* output = new int[n];
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
delete[] count;
delete[] output;
}
桶排序(Bucket Sort):
void bucketSort(int arr[], int n, int bucketSize) {
int maxVal = *std::max_element(arr, arr + n);
int minVal = *std::min_element(arr, arr + n);
int bucketNum = (maxVal - minVal) / bucketSize + 1;
std::vector<std::vector<int>> buckets(bucketNum);
for (int i = 0; i < n; i++) {
int idx = (arr[i] - minVal) / bucketSize;
buckets[idx].push_back(arr[i]);
}
int k = 0;
for (int i = 0; i < bucketNum; i++) {
if (!buckets[i].empty()) {
std::sort(buckets[i].begin(), buckets[i].end());
for (int j = 0; j < buckets[i].size(); j++) {
arr[k++] = buckets[i][j];
}
}
}
}
基数排序(Radix Sort):
int getMax(int arr[], int n) {
int maxVal = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > maxVal) {
maxVal = arr[i];
}
}
return maxVal;
}
void countSort(int arr[], int n, int exp) {
int* output = new int[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[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];
}
delete[] output;
}
void radixSort(int arr[], int n) {
int maxVal = getMax(arr, n);
for (int exp = 1; maxVal / exp > 0; exp *= 10) {
countSort(arr, n, exp);
}
}
计数排序(Counting Sort)适用于范围较小且整数的排序。
void countingSort(int arr[], int n) {
int maxVal = *std::max_element(arr, arr + n);
int* count = new int[maxVal + 1]{0};
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
int k = 0;
for (int i = 0; i <= maxVal; i++) {
while (count[i] > 0) {
arr[k++] = i;
count[i]--;
}
}
delete[] count;
}
基数排序(Radix Sort)适用于有多个关键字的排序,如字符串排序。
void radixSort(string arr[], int n, int maxLen) {
vector<string> output(arr, arr + n);
for (int pos = maxLen - 1; pos >= 0; pos--) {
int count[256] = {0};
for (int i = 0; i < n; i++) {
count[arr[i][pos]]++;
}
for (int i = 1; i < 256; i++) {
count[i] += count[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i][pos]] - 1] = arr[i];
count[arr[i][pos]]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
}
块排序(Bucket Sort)适用于数据分布较为均匀的情况。
void bucketSort(int arr[], int n, int numBuckets) {
int maxVal = *std::max_element(arr, arr + n);
int minVal = *std::min_element(arr, arr + n);
double range = (maxVal - minVal + 1) / static_cast<double>(numBuckets);
vector<vector<int>> buckets(numBuckets);
for (int i = 0; i < n; i++) {
int index = static_cast<int>((arr[i] - minVal) / range);
buckets[index].push_back(arr[i]);
}
for (int i = 0; i < numBuckets; i++) {
sort(buckets[i].begin(), buckets[i].end());
}
int k = 0;
for (int i = 0; i < numBuckets; i++) {
for (int j = 0; j < buckets[i].size(); j++) {
arr[k++] = buckets[i][j];
}
}
}
珠排序(Bead Sort)
void beadSort(std::vector<int>& arr) {
int maxVal = *std::max_element(arr.begin(), arr.end());
std::vector<std::vector<char>> grid(maxVal, std::vector<char>(arr.size(), ' '));
for (int j = 0; j < arr.size(); j++) {
for (int i = 0; i < arr[j]; i++) {
grid[maxVal-1-i][j] = '*';
}
}
std::vector<int> sortedArr;
for (int i = 0; i < maxVal; i++) {
std::vector<int> sortedRow;
for (int j = 0; j < arr.size(); j++) {
if (grid[i][j] == '*') {
sortedRow.push_back(arr[j]);
}
}
sort(sortedRow.begin(), sortedRow.end());
sortedArr.insert(sortedArr.end(), sortedRow.begin(), sortedRow.end());
}
for (int i = 0; i < sortedArr.size(); i++) {
arr[i] = sortedArr[i];
}
}
鸽巢排序(Pigeonhole Sort)
void pigeonholeSort(std::vector<int>& arr) {
int minVal = *std::min_element(arr.begin(), arr.end());
int maxVal = *std::max_element(arr.begin(), arr.end());
int range = maxVal - minVal + 1;
std::vector<int> pigeonholes(range, 0);
for (int num : arr) {
pigeonholes[num - minVal]++;
}
int index = 0;
for (int i = 0; i < range; i++) {
while (pigeonholes[i] > 0) {
arr[index++] = i + minVal;
pigeonholes[i]--;
}
}
}
荷兰国旗问题排序(Dutch National Flag Sort)
void dutch_flag_sort(vector<int>& nums) {
int low = 0;
int mid = 0;
int high = nums.size() - 1;
int pivot = 1; // 划分值,这里以1为例
while (mid <= high) {
if (nums[mid] < pivot) {
swap(nums[low], nums[mid]);
low++;
mid++;
} else if (nums[mid] > pivot) {
swap(nums[mid], nums[high]);
high--;
} else {
mid++;
}
}
}
缩小增量排序(Shell Sort)
void shellSort(std::vector<int>& nums) {
int n = nums.size();
int gap = n / 2; // 初始化间隔大小
while (gap > 0) {
for (int i = gap; i < n; ++i) {
int temp = nums[i];
int j = i;
// 对子序列进行插入排序
while (j >= gap && nums[j - gap] > temp) {
nums[j] = nums[j - gap];
j -= gap;
}
nums[j] = temp;
}
gap /= 2; // 缩小间隔
}
}
Tim排序(Tim Sort)
const int MIN_RUN = 32;
void insertionSort(std::vector<int>& nums, int left, int right) {
for (int i = left + 1; i <= right; ++i) {
int temp = nums[i];
int j = i - 1;
while (j >= left && nums[j] > temp) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = temp;
}
}
void merge(std::vector<int>& nums, int left, int mid, int right) {
int len1 = mid - left + 1;
int len2 = right - mid;
std::vector<int> leftArr(len1);
std::vector<int> rightArr(len2);
for (int i = 0; i < len1; ++i) {
leftArr[i] = nums[left + i];
}
for (int j = 0; j < len2; ++j) {
rightArr[j] = nums[mid + 1 + j];
}
int i = 0;
int j = 0;
int k = left;
while (i < len1 && j < len2) {
if (leftArr[i] <= rightArr[j]) {
nums[k] = leftArr[i];
i++;
} else {
nums[k] = rightArr[j];
j++;
}
k++;
}
while (i < len1) {
nums[k] = leftArr[i];
i++;
k++;
}
while (j < len2) {
nums[k] = rightArr[j];
j++;
k++;
}
}
void timSort(std::vector<int>& nums) {
int n = nums.size();
for (int i = 0; i < n; i += MIN_RUN) {
insertionSort(nums, i, std::min(i + MIN_RUN - 1, n - 1));
}
for (int size = MIN_RUN; size < n; size *= 2) {
for (int left = 0; left < n; left += 2 * size) {
int mid = left + size - 1;
int right = std::min(left + 2 * size - 1, n - 1);
merge(nums, left, mid, right);
}
}
}
猴子排序(Monkey Sort)
#include <iostream>
#include <vector>
#include <random>
#include <algorithm>
bool isSorted(const std::vector<int>& arr) {
for (int i = 1; i < arr.size(); i++) {
if (arr[i] < arr[i - 1]) {
return false;
}
}
return true;
}
void monkeySort(std::vector<int>& arr) {
std::random_device rd;
std::mt19937 rng(rd());
while (!isSorted(arr)) {
std::shuffle(arr.begin(), arr.end(), rng);
}
}
int main() {
std::vector<int> arr = {5, 3, 2, 8, 7, 9, 1, 4, 6};
monkeySort(arr);
for (int i = 0; i < arr.size(); i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
猴子排序,永远的信仰!
Monkey sort!!!!!!!!!