八种经典排序算法实现-优快云博客

写在前面： 我是「虐猫人薛定谔i」，一个不满足于现状，有梦想，有追求的00后
$\quad$
本博客主要记录和分享自己毕生所学的知识，欢迎关注，第一时间获取更新。
$\quad$
不忘初心，方得始终。
$\quad$

❤❤❤❤❤❤❤❤❤❤

文章目录

冒泡排序
直接插入排序
希尔排序
直接选择排序
堆排序
快速排序
归并排序
基数排序

冒泡排序

#include <iostream>
using namespace std;
//冒泡排序
void BubbleSort(int *a,int n)
{
    for(int i=0;i<n;++i)
    {
        int exchange=false;
        for(int j=0;j<n-i-1;++j)
        {
            if(a[j]>a[j+1])
            {
                exchange=true;
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
        if(exchange==false)
        {
            break;
        }
    }
}
//冒泡排序测试
int main()
{
    int n;
    cin>>n;
    int *nums = new int[n+1];
    for(int i=0;i<n;++i)
    {
        cin>>nums[i];
    }
    BubbleSort(nums,n);
    for(int i=0;i<n;++i)
    {
        if(i==0)
        {
            cout<<nums[i];
        }
        else
        {
            cout<<","<<nums[i];
        }
    }
    delete[] nums;
    return 0;
}

直接插入排序

#include <iostream>
using namespace std;

// 直接插入排序
void InsertSort(int *arr, int n)
{
    for (int i = 1; i < n; ++i)
    {
        int tmp = arr[i];
        for (int j = i - 1; j >= 0; --j)
        {
            if (tmp < arr[j])
            {
                arr[j + 1] = arr[j];
                arr[j] = tmp;
            }
            else
            {
                break;
            }
        }
    }
}

// 测试插入排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    InsertSort(arr, n);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] arr;
    return 0;
}

希尔排序

#include <iostream>
#include <array>
using namespace std;


// 希尔排序
void ShellSort(int *arr, int n)
{
    // 增量序列
    array<int, 3> dk = {5, 3, 1};
    for (size_t k = 0; k < dk.size(); ++k)
    {
        for (int i = dk[k]; i < n; ++i)
        {
            int tmp = arr[i];
            for (int j = i - dk[k]; j >= 0; j -= dk[k])
            {
                if (tmp < arr[j])
                {
                    arr[j+dk[k]] = arr[j];
                    arr[j] = tmp;
                }
                else
                {
                    break;
                }
                
            }
        }
    }
}


// 测试希尔排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    ShellSort(arr, n);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] arr;
    return 0;
}

直接选择排序

#include <iostream>
using namespace std;
const int INF = 0x3f3f3f;

// 简单的选择排序
void SelectSort(int *arr, int n)
{
    for (int i = 0; i < n; ++i)
    {
        int minn = INF;
        int pos = -1;
        for (int j = i; j < n; ++j)
        {
            if (arr[j] < minn)
            {
                minn = arr[j];
                pos = j;
            }
        }
        if (i != pos)
        {
            int t = arr[i];
            arr[i] = arr[pos];
            arr[pos] = t;
        }
    }
}


// 测试简单选择排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    SelectSort(arr, n);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] arr;
    return 0;
}

堆排序

#include <iostream>
using namespace std;

/*
*  a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
*　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
*　c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
*/


// 调整
void HeapAdjust(int *arr, int i, int n)
{
    int tmp = arr[i];
    for (int k = 2 * i + 1; k < n; k = k * 2 + 1)
    {
        if (k + 1 < n && arr[k] < arr[k+1])
        {
            ++k;
        }
        if (arr[k] > tmp)
        {
            arr[i] = arr[k];
            i = k;
        }
        else
        {
            break;
        }
        
    }
    arr[i] = tmp;
}


// 堆排序
void HeapSort(int *arr, int n)
{
    for (int i = n / 2 - 1; i >= 0; --i)
    {
        HeapAdjust(arr, i, n);
    }
    for (int j = n - 1; j > 0; --j)
    {
        int tmp = arr[0];
        arr[0] = arr[j];
        arr[j] = tmp;
        HeapAdjust(arr, 0, j);
    }
}


// 测试堆排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    HeapSort(arr, n);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] arr;
    return 0;
}

快速排序

#include <iostream>
using namespace std;


// 快速排序
void QuickSort(int *arr, int low, int high)
{
    if (low < high)
    {
        int i = low;
        int j = high;
        int temp = arr[i];
        while (i < j)
        {
            while (i < j && arr[j] >= temp)
            {
                --j;
            }
            arr[i] = arr[j];
            arr[j] = temp;
            while (i < j && arr[i] <= temp)
            {
                ++i;
            }
            arr[j] = arr[i];
            arr[i] = temp;
        }
        QuickSort(arr, low, i);
        QuickSort(arr, i+1, high);
    }
}


// 测试快速排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    QuickSort(arr, 0, n-1);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] arr;
    return 0;
}

归并排序

#include <iostream>
using namespace std;

// 辅助数组
int *tmp;

// 合并操作
void Merge(int *arr1, int *arr2, int left, int mid, int right)
{
    int i = left;
    int j = mid + 1;
    int t = 0;
    while (i <= mid && j <= right)
    {
        if (arr2[i] <= arr2[j])
        {
            arr1[t++] = arr2[i++];
        }
        else
        {
            arr1[t++] = arr2[j++];
        }
    }
    while (i <= mid)
    {
        arr1[t++] = arr2[i++];
    }
    while (j <= right)
    {
        arr1[t++] = arr2[j++];
    }
    t = 0;
    while (left <= right)
    {
        arr2[left++] = arr1[t++];
    }
}


// 归并排序
void MergeSort(int * arr, int *dest, int s, int t)
{
    if (s == t)
    {
        dest[s] = arr[s];
    }
    else
    {
        int m = (s + t) / 2;
        MergeSort(arr, tmp, s, m);
        MergeSort(arr, tmp, m + 1, t);
        Merge(tmp, arr, s, m, t);
    }
    
}


// 测试归并排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    tmp = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    MergeSort(arr, arr, 0, n-1);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    delete [] tmp;
    delete [] arr;
    return 0;
}

基数排序

#include <iostream>
#include <vector>
#include <array>
using namespace std;
const int radix = 10;
array<vector<int>, radix> bucket;
// 关键字的最大位数
const int keynum = 3;
// 分配
void Distribute(int *arr, int n, int i)
{
    // 初始化
    for (int j = 0; j < radix; ++j)
    {
        bucket[j].clear();
    }
    for (int j = 0; j < n; ++j)
    {
        int k = -1;
        switch (i)
        {
        case 1:
            k = arr[j] % 100 % 10;
            break;
        case 2:
            k = arr[j] % 100 / 10;
            break;
        case 3:
            k = arr[j] / 100;
            break;
        default:
            break;
        }
        if (k < 0 || k >= bucket.size())
        {
        	cout << "error" << endl;
            exit(-1);
        }
        // cout << k << endl;
        bucket[k].push_back(arr[j]);
    }
}
// 收集
void Collect(int *arr)
{
    int t = 0;
    for (int i = 0; i < radix; ++i)
    {
        if (!bucket[i].empty())
        {
            for (size_t j = 0; j < bucket[i].size(); ++j)
            {
                arr[t++] = bucket[i][j];
            }
        }
    }
    // for (int i = 0; i < t; ++i)
    // {
    //     cout << arr[i] << " ";
    // }
    // cout << endl;
}
// 基数排序
void RadixSort(int *arr, int n)
{
    for (int i = 1; i <= keynum; ++i)
    {
        Distribute(arr, n, i);
        Collect(arr);
    }
}



// 测试基数排序
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    RadixSort(arr, n);
    for (int i = 0; i < n; ++i)
    {
        cout << arr[i] << " ";
    }
    return 0;
}