考研408笔试之排序算法代码实现汇总

各种排序算法汇总

因为分开写太麻烦了QAQ，直接放在一起吧。

写在前面

本文不详细探讨各种排序的原理，只涉及具体的代码实现，了解算法原理，翻阅一些资料可以写出各种排序的代码实现。本文进行汇总，以题目的形式给出。

题目描述

给定你一个长度为 $n$ 的整数数列。
请你使用快速排序对这个数列按照从小到大进行排序。
并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 $n$。
第二行包含 $n$ 个整数（所有整数均在 $1\sim 10^9$ 范围内），表示整个数列。

输出格式

输出共一行，包含 $n$ 个整数，表示排好序的数列。

数据范围

$1\le n\le 100000$

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

参考代码cpp

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int q[N], n, w[N], sz, s[N];

void bubble_sort() // 冒泡排序
{
    for (int i = 0; i < n; i ++) // 迭代n - 1次
    {
        bool is_swap = false; // 设置优化参数 is_swap 表示是否交换位置
        for (int j = n - 1; j > i; j --) // 从最后一个元素到第i + 1个元素
            if (q[j] < q[j - 1]) // 当前元素比前一个小就交换位置
            {
                is_swap = true; // 设置已交换过
                swap(q[j], q[j - 1]); // 交换位置
            }
        if (!is_swap) break; // 如果当前枚举过程中未交换，则数组有序，提前结束排序
    }
}

void insert_sort() // 简单插入排序
{
    for (int i = 1; i < n; i ++) // 第一个元素有序，从第二个元素开始遍历 
    {
        int j = i, t = q[i]; // 保存当前元素
        while (j && q[j - 1] > t) // 当前面的元素比当前元素大时，后移
        {
            q[j] = q[j - 1]; 
            j --;
        } // 找到了恰当的位置
        q[j] = t; // 放入当前元素 
    }
}

void binary_search_insert_sort() // 折半插入排序
{
    for (int i = 1; i < n - 1; i ++)
    {
        if (q[i - 1] <= q[i]) continue; // 特判当前元素是否无需改变位置
        int x = q[i];
        int l = 0, r = i - 1;
        while (l < r) // 二分找到恰当的位置
        {
            int mid = l + r >> 1;
            if (q[mid] > x ) r = mid ;
            else l = mid + 1;
        }
        for (int j = i - 1; j >= r; j --) // 把 r ～ i - 1 向后移一位
            q[j + 1] = q[j];
        q[r] = x; // 放入被插入的元素
    }
}

void select_sort() // 简单选择排序
{
    for (int i = 0; i < n - 1; i ++) // 枚举n - 1次
    {
        int k = i;
        for (int j = i; j < n; j ++) // 找到最小元素放入当前位置
            if (q[k] > q[j])
                k = j;
        swap(q[i], q[k]);
    }
}

void shell_sort(int n) // 希尔排序
{
    for (int d = n / 2 ; d; d /= 2) // 枚举增量（公差）
    {
        for (int start = 0; start < d; start ++) // 枚举每个组
        {
            for (int i = start + d; i < n; i += d) // 每个组中元素进行插入排序
            {
                int t = q[i], j = i;
                while (j > start && q[j - d] > t)
                {
                    q[j] = q[j - d];
                    j -= d;
                }
                q[j] = t;
            }
        }
    }
}

void down(int u) // 堆操作
{
    int t = u;
    if (u * 2 <= sz && q[u * 2] > q[t]) t = u * 2; //保留左、右子树和该节点中最大的节点元素
    if (u * 2 + 1 <= sz && q[u * 2 + 1] > q[t]) t = u * 2 + 1;
    if (u != t) // 若最大的不是该节点本身
    {
        swap(q[u], q[t]); // 交换位置
        down(t); // 递归down操作
    }
}

void heap_sort(int n) // 堆排序
{
    sz = n; // 保存节点个数
    for (int i = n / 2; i; i --) down(i); // 建树
    for (int i = 0; i < n - 1; i ++) // 排序过程：删除最大的元素，保存到树的末尾中
    {
         swap(q[1], q[sz]);
         sz --;
         down(1);
    }
}

void quick_sort(int l, int r) // 快速排序
{
    if (l >= r) return ; // 判断是否越界
    int i = l - 1, j = r + 1, mid = q[l + r >> 1];
    while (i < j) // 划分
    {
        do ++i; while (q[i] < mid); // 走左指针
        do --j; while (q[j] > mid); // 走右指针
        if (i < j)
            swap(q[i], q[j]); // 交换位置，直至指针重合才算完成划分
    }
    quick_sort(l, j); // 对左端进行快排
    quick_sort(j + 1, r); // 对右端进行快排
}

void merge_sort(int l, int r) // 归并排序
{
    if (l >= r) return ; // 判读是否越界
    int mid = l + r >> 1;
    merge_sort(l, mid); // 递归左端
    merge_sort(mid + 1, r); // 递归右端
    // 二路归并
    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] < q[j]) w[k ++] = q[i ++];
        else w[k ++] = q[j ++];

    while (i <= mid) w[k ++] = q[i ++];
    while (j <= r) w[k ++] = q[j ++];
    for (int i = l, j = 0; i <= r;)
        q[i ++] = w[j ++];
}

void bucket_sort() // 桶排序
{
    for (int i = 0; i < n; i ++ ) s[q[i]] ++ ;
    for (int i = 1; i < N; i ++ ) s[i] += s[i - 1];
    for (int i = n - 1; i >= 0; i --) w[ -- s[q[i]]] = q[i];
    for (int i = 0; i < n; i ++ ) q[i] = w[i];
}

void radix_sort(int d, int r) // 基数排序
{
    int radix = 1;
    for (int i = 1; i <= d; i ++ )
    {
        for (int j = 0; j < r; j ++ ) s[j] = 0;
        for (int j = 0; j < n; j ++ ) s[q[j] / radix % r] ++;
        for (int j = 1; j < r; j ++ ) s[j] += s[j - 1];
        for (int j = n - 1; j >= 0; j --) w[ -- s[q[j] / radix % r]] = q[j];

        for (int j = 0; j < n; j ++ ) q[j] = w[j];
        radix *= r;
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++) scanf("%d", &q[i]);

    // bubble_sort();
    // select_sort();
    // quick_sort(0, n - 1);
    // merge_sort(0, n - 1);
    // insert_sort();
    // binary_search_insert_sort();
    // shell_sort(n);
    // heap_sort(n);
    // bucket_sort();
    radix_sort(10, 10);
    for (int i = 1; i <= n; i ++) printf("%d ", q[i]);
    return 0;
    
}

总结

虽然是考研408数据结构中的内容，但也同样也可能会在找工作、面试中作为笔试题中出现，也可以进行学习实现，并熟练码出。

已完结