C++最难的十种排序算法【学不会私信我】（中）

本文链接：https://blog.youkuaiyun.com/YoyoHuzeyou/article/details/133322537

必须要看的前言

浪子已经等不及要出新文啦

虽然目标没完成，3天了，只有4个赞。。。比预期少一个，呜呜~~~~

网址：C++最难的十种排序算法【学不会私信我】（上）_浪子小院的博客-优快云博客

不过，还行吧，这次浪子要求也不过分，就5个赞，比上次进步一点点，好吗？评论去告诉浪子哦！还有，凡是三连的大佬们，浪子都会一一按照评论区顺序回访哦~~没回访的私信浪子。

下面，正文来喽——

5.睡眠排序（Sleep Sort）

睡眠排序是一种非常奇特的排序算法，它利用了多线程的特性。该算法将待排序序列中的每个元素作为一个任务，并为其创建一个线程。然后，每个线程在指定时间后输出自己的值，从而实现排序。尽管很有趣，但实际上并不实用，因为时间复杂度很高，并且需要处理与线程相关的问题。

#include <iostream>
#include <vector>
#include <thread>
#include <chrono>

void sleepSort(std::vector<int>& arr) {
    std::vector<std::thread> threads;

    for (int num : arr) {
        threads.emplace_back([num]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(num));
            std::cout << num << " ";
        });
    }

    for (std::thread& t : threads) {
        t.join();
    }
}

int main() {
    std::vector<int> arr = {5, 2, 9, 1, 5, 6, 3};
    
    std::cout << "Original array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    sleepSort(arr);
    
    std::cout << std::endl;

    return 0;
}

6.臭皮匠排序（Stooge Sort）

臭皮匠排序是一种递归的排序算法，它基于分治的思想。该算法通过将待排序序列的前两部分和后两部分分别排序，然后再递归地对剩余部分进行排序。最后，通过交换头尾元素，确保整个序列有序。

#include <iostream>
#include <vector>

void stoogeSort(std::vector<int>& arr, int left, int right) {
    if (arr[left] > arr[right]) {
        std::swap(arr[left], arr[right]);
    }

    if ((right - left + 1) > 2) {
        int t = (right - left + 1) / 3;

        stoogeSort(arr, left, right - t);
        stoogeSort(arr, left + t, right);
        stoogeSort(arr, left, right - t);
    }
}

int main() {
    std::vector<int> arr = {5, 2, 9, 1, 5, 6, 3};
    
    std::cout << "Original array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    stoogeSort(arr, 0, arr.size() - 1);
    
    std::cout << "Sorted array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

7.范围排序（Pancake Sort）

范围排序是一种以翻转操作为基础的排序算法。该算法通过多次选择待排序序列的最大元素并进行翻转来实现排序。具体过程是，首先找到待排序序列中的最大值的索引，然后将该最大值翻转到序列的开头，接着再将整个序列翻转，使最大值移动到正确的位置。通过重复这个过程，我们可以逐步将序列排序。

#include <iostream>
#include <vector>

int findMaxIndex(std::vector<int>& arr, int n) {
    int maxIndex = 0;

    for (int i = 0; i < n; ++i) {
        if (arr[i] > arr[maxIndex]) {
            maxIndex = i;
        }
    }

    return maxIndex;
}

void flip(std::vector<int>& arr, int i) {
    int start = 0;
    while (start < i) {
        std::swap(arr[start], arr[i]);
        start++;
        i--;
    }
}

void pancakeSort(std::vector<int>& arr) {
    int n = arr.size();

    for (int currSize = n; currSize > 1; --currSize) {
        int maxIndex = findMaxIndex(arr, currSize);

        if (maxIndex != currSize - 1) {
            flip(arr, maxIndex);
            flip(arr, currSize - 1);
        }
    }
}

int main() {
    std::vector<int> arr = {5, 2, 9, 1, 5, 6, 3};
    
    std::cout << "Original array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    pancakeSort(arr);
    
    std::cout << "Sorted array: ";
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

好啦，结束啦——

记住，只要5个赞哦~~~

感谢大佬们的支持！

下次，浪子将分享红绿灯排序，最差情况复杂度为 O(n^2) 的快速排序和平方根排序哦。