常用排序算法整理

#include 
#include 
#include 
#include 
#include 

using namespace std;
// 交换
void swap(vector& ans, int i, int j)
{
    int tmp = ans[j];
    ans[j] = ans[i];
    ans[i] = tmp;
}
// 打印数组
void print(vector ans)
{
    for (auto& num : ans)
        cout << num << " ";
}

// 冒泡排序
void bubbleSort(vector& ans)
{
    bool flag = true; // 是否有数据交换
    for (int i = 0; i < ans.size() && flag; i++) {
        flag = false;
        for (int j = ans.size() - 1; j > i; j--) {
            if (ans[j - 1] > ans[j]) {
                swap(ans, j - 1, j);
                flag = true; // 说明有数据交换
            }
        }
    }
}

// 快排
void quickSort(vector& ans, int l, int r)
{
    if (l >= r)
        return;
    int tmp = ans[l];
    int i = l;
    int j = r;
    while (i < j) {
        while (i < j && ans[j] > tmp) {
            j--;
        }
        ans[i] = ans[j];
        while (i < j && ans[i] <= tmp) {
            i++;
        }
        ans[j] = ans[i];
    }
    ans[i] = tmp;
    quickSort(ans, l, i - 1);
    quickSort(ans, i + 1, r);
}

// 简单选择排序
void selectSort(vector& ans)
{
    int min;
    for (int i = 0; i < ans.size() - 1; i++) {
        min = i;
        for (int j = i + 1; j < ans.size(); j++) {
            if (ans[min] > ans[j])
                min = j;
        }
        if (min != i)
            swap(ans, min, i);
    }
}

// 堆排
void sink(vector& ans, int sz, int index)
{ // 辅助函数：下沉
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int older = left < sz ? left : -1;
    if (right < sz && ans[older] < ans[right] && older > 0)
        older = right;
    if (ans[older] > ans[index] && older > 0) { // 说明父节点比左右孩子节点中的一个要小
        swap(ans, older, index);
        sink(ans, sz, older); // 继续往下判断，递归下沉
    }
}
void heapSort(vector& ans, int sz)
{
    // 从最后一个非叶子节点开始，将所有非叶子节点下沉
    for (int i = sz / 2 - 1; i >= 0; i--) {
        sink(ans, sz, i);
    }
    // 将最大的元素放在最后，然后重新下沉第一个元素（交换导致大顶堆性质变化）
    // 只剩最后一个元素的时候无需再下沉
    for (int i = sz - 1; i >= 1; i--) {
        swap(ans, 0, i);
        // 数组下标范围减小
        sink(ans, i, 0);
    }
}

// 插入排序
void insertionSort(vector& ans)
{
    for (int i = 1; i < ans.size(); i++) {
        int tmp = ans[i];
        int j = i - 1;
        while (j >= 0 && ans[j] > tmp) {
            ans[j + 1] = ans[j];
            j--;
        }
        ans[j + 1] = tmp;
    }
}

// 希尔排序
void shellSort(vector& ans)
{
    int gap = ans.size() / 2;
    while (gap) {
        for (int i = gap; i < ans.size(); i++) {
            int tmp = ans[i];
            int j = i - gap;
            while (j >= 0 && ans[j] > tmp) {
                ans[j + gap] = ans[j];
                j -= gap;
            }
            ans[j + gap] = tmp; // 放入空位
        }
        gap /= 2;
    }
}

// 归并排序
void mergeSort(vector& ans, int l, int r)
{
    if (l >= r)
        return;
    vector tmp;
    int mid = l + (r - l) / 2;
    mergeSort(ans, l, mid);
    mergeSort(ans, mid + 1, r);
    int i = l, j = mid + 1;
    while (i <= mid && j <= r) {
        if (ans[i] > ans[j]) {
            tmp.push_back(ans[j++]);
        } else {
            tmp.push_back(ans[i++]);
        }
    }
    while (i <= mid)
        tmp.push_back(ans[i++]);
    while (j <= r)
        tmp.push_back(ans[j++]);
    copy(tmp.begin(), tmp.end(), ans.begin() + l);
}

// 基数排序  待更新
void radixSort(vector& ans)
{
}

int main()
{
    vector ans({ 5, 4, 3, 2, 1 });
    // bubbleSort(ans);
    // quickSort(ans, 0, ans.size() - 1);
    // selectSort(ans);
    // heapSort(ans, ans.size());
    // insertionSort(ans);
    // shellSort(ans);
    // mergeSort(ans, 0, ans.size() - 1);
    radixSort(ans);
    print(ans);
    return 0;
}