几种排序算法的C++实现

本博客为实验作品，测试下在CSDN上此类博客的传播度。

// 下面为各个版本的排序算法的实现
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

int getMid(vector<int> &nums, int left, int right);
// 快速排序 平均nlog(n)，最坏O(n^2)，空间：O(nlog(n))，不稳定
// 分为三个步骤：
// 1. 以第一元素做pivot，交换两侧元素，直至左侧皆小于pivot，右侧皆大于
// 2. 对左侧进行递归快排
// 3. 对右乘进行递归快排
void swap(vector<int> &nums, int i1, int i2)
{
    int temp = nums[i1];
    nums[i1] = nums[i2];
    nums[i2] = temp;
}
void quick_sort(vector<int> &nums, int left, int right)
{
    if (left < right)
    {
        int mid = getMid(nums, left, right);
        quick_sort(nums, left, mid - 1);
        quick_sort(nums, mid + 1, right);
    }
}
int getMid(vector<int> &nums, int left, int right)
{
    int pivot = nums[left];
    while (left < right)
    {
        while (nums[right] >= pivot && left < right)
        {
            right--;
        }
        nums[left] = nums[right];
        while (nums[left] <= pivot && left < right)
        {
            left++;
        }
        nums[right] = nums[left];
    }
    nums[left] = pivot;
    return left;
}
// 归并排序
// 基本递归单元：组两两合并，合并时依次判断头部元素的大小
void merge_sort(vector<int> &nums, int left, int right, vector<int> &temp)
{
    if (left >= right)
    {
        return;
    }
    int mid = left + (right - left) / 2;
    // 分割
    merge_sort(nums, left, mid, temp);
    merge_sort(nums, mid + 1, right, temp);
    // 合并
    int p = left, q = mid + 1, i = left;
    while (p <= mid || q <= right)
    {
        if (q > right || (p <= mid && nums[p] <= nums[q]))
        {
            temp[i++] = nums[p++];
        }
        else
        {
            temp[i++] = nums[q++];
        }
    }
    for (i = left; i <= right; ++i)
    {
        nums[i] = temp[i];
    }
}
// 插入排序，左有序，有无序
void insert_sort(vector<int> &nums)
{
    int size = nums.size();
    for (size_t i = 1; i < size; i++)
    {
        int j = i;
        int key = nums[j];
        for (; j > 0; j--)
        {
            if (nums[j - 1] > key)
            {
                nums[j] = nums[j - 1];
            }
            else
            {
                break;
            }
        }
        nums[j] = key;
    }
}
// 冒泡，如果左比右大，则交换，每一趟会把最大值换到最后面
// 如果某趟没有进行交换，则说明已经有序
void bubble_sort(vector<int> &nums)
{
    for (int i = 0; i < nums.size(); i++)
    {
        bool hasSwap = false;
        for (int j = 0; j < nums.size() - 1 - i; j++)
        {
            if (nums[j] > nums[j + 1])
            {
                int temp = nums[j + 1];
                nums[j + 1] = nums[j];
                nums[j] = temp;
                hasSwap = true;
            }
        }
        if (hasSwap == false)
            break;
    }
}
// 选择排序：找到当前的最大值，和最末尾数字进行交换
void selection_sort(vector<int> &nums)
{
    int size = nums.size();
    for (int i = 0; i < nums.size(); i++)
    {
        int index = 0;
        int max = nums[0];
        for (size_t j = 0; j < nums.size() - i; j++)
        {
            if (nums[j] > max)
            {
                index = j;
                max = nums[j];
            }
        }
        nums[index] = nums[size - 1 - i];
        nums[size - 1 - i] = max;
    }
}
// 堆排序
void heapify(vector<int> &nums, int size, int index)
{
    if (index >= size)
    {
        return;
    }
    int c1 = index * 2 + 1;
    int c2 = index * 2 + 2;
    int max_i = index;
    if (c1 < size && nums[c1] > nums[max_i])
    {
        max_i = c1;
    }
    if (c2 < size && nums[c2] > nums[max_i])
    {
        max_i = c2;
    }
    if (max_i != index)
    {
        swap(nums, max_i, index);
        heapify(nums, size, max_i);
    }
}
// 造堆需要从最后一个节点的父节点开始
void build_heap(vector<int> &nums)
{
    int last = nums.size() - 1;
    int parent = (last - 1) / 2;
    for (int i = parent; i >= 0; i--)
    {
        heapify(nums, nums.size(), i);
    }
}
void heap_sort(vector<int> &nums)
{
    build_heap(nums);
    int size = nums.size();
    for (int i = size - 1; i >= 0; i--)
    {
        swap(nums, 0, i);
        heapify(nums, i, 0);
    }
}

// 基排序
void radix_sort(vector<int> &nums)
{
    int size = nums.size();
    int max = nums[0];
    for (size_t i = 1; i < size; i++)
    {
        if (max < nums[i])
        {
            max = nums[i];
        }
    }
    int base = 1;
    vector<int> s(size);
    while (max / base > 0)
    {
        int bucket[10] = {0};
        for (size_t i = 0; i < size; i++)
        {
            bucket[nums[i] / base % 10]++;
        }
        for (size_t i = 1; i < 10; i++)
        {
            bucket[i] += bucket[i - 1];
        }
        for (int i = size -1 ; i >= 0; i--)
        {
            s[bucket[nums[i] / base % 10]-1] = nums[i];
            bucket[nums[i] / base % 10]--;
        }
        for (size_t i = 0; i < size; i++)
        {
            nums[i] = s[i];
        }
        base *= 10;
    }
}
int main(int argc, char **argv)
{
    vector<int> origin_nums = {4,100,205,61,61,26,35};
    vector<int> nums = origin_nums;
    int size = nums.size();
    int left = 0, right = size - 1;
    quick_sort(nums, left, right);
    cout << "quick_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    vector<int> temp(nums.size());
    merge_sort(nums, left, right, temp);
    cout << "merge_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    bubble_sort(nums);
    cout << "bubble_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    selection_sort(nums);
    cout << "selection_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    insert_sort(nums);
    cout << "insert_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    heap_sort(nums);
    cout << "heap_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;

    nums = origin_nums;
    radix_sort(nums);
    cout << "radix_sort: ";
    for_each(nums.begin(), nums.end(), [](int i)
             { cout << i << " "; });
    cout << endl;
}