排序算法

几种排序算法的时间复杂度：

1、插入排序

#include <iostream>
#include <fstream>
#include <string>

const int maxn = 10005;
int arr[maxn];
int n;

void insertion_sort()
{
    for (int i = 1; i < n; ++i)
    {
        int key = arr[i];
        int j = i;
        while (j - 1 >= 0 && arr[j - 1] > key)
        {
            arr[j] = arr[j - 1];
            --j;
        }
        arr[j] = key;
    }
}
void print_arr(const int *arr, int n)
{
    for (int i = 0; i < n; ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
int main()
{
    std::ifstream is("in.txt");
    while (is >> arr[n++]);
    --n;
    print_arr(arr, n);
    insertion_sort();
    print_arr(arr, n);
    return 0;
}

2、归并排序

#include <iostream>
#include <fstream>
#include <string>

const int maxn = 10005;
int arr[maxn], L[maxn], R[maxn];
int n;

void merge(int *arr, int l, int r)
{
    int mid = (l + r) / 2;
    int n1 = mid - l + 1;
    int n2 = r - mid;
    for (int i = 0; i < n1; ++i)
        L[i] = arr[l + i];
    for (int i = 0; i < n2; ++i)
        R[i] = arr[mid + i + 1];
    int i = 0, j = 0;
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
            arr[l++] = L[i++];
        else
            arr[l++] = R[j++];
    }
    while (i < n1)
        arr[l++] = L[i++];
    while (j < n2)
        arr[l++] = R[j++];
}

void merge_sort(int *arr, int l, int r)
{
    if (l == r)
        return;
    int mid = (l + r) / 2;
    merge_sort(arr, l, mid);
    merge_sort(arr, mid + 1, r);
    merge(arr, l, r);
}

void print_arr(const int *arr, int n)
{
    for (int i = 0; i < n; ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
int main()
{
    std::ifstream is("in.txt");
    while (is >> arr[n++]);
    --n;
    print_arr(arr, n);
    merge_sort(arr, 0, n - 1);
    print_arr(arr, n);
    return 0;
}

3、堆排序

#include <iostream>
#include <fstream>
#include <string>

template<typename T>
void swap(T &x, T &y) {
    T temp = x;
    x = y;
    y = temp;
}

const int maxn = 10005;
int arr[maxn];
int n;


void max_heapinf(int *arr, int i, int length) // 维护堆的性质
{
    int l = 2 * i, r = l + 1;
    int largest = i;
    if (l <= length && arr[l] > arr[largest])
        largest = l;
    if (r <= length && arr[r] > arr[largest])
        largest = r;
    if (largest != i)
    {
        swap(arr[largest], arr[i]);
        max_heapinf(arr, largest, length);
    }
}

void build_max_heap(int *arr) // 建堆
{
    int length = n;
    for (int i = n / 2; i >= 1; i--)
        max_heapinf(arr, i, length);
}

void heapsort(int *arr)
{
    build_max_heap(arr);
    int length = n;
    for (int i = n; i >= 2; --i)
    {
        swap(arr[i], arr[1]);
        --length;
        max_heapinf(arr, 1, length);
    }
}

void print_arr(const int *arr,int l, int r)
{
    for (int i = l; i <= r; ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
int main()
{
    std::ifstream is("in.txt");
    while (is >> arr[++n]);
    --n;
    print_arr(arr, 1, n);
    heapsort(arr);
    print_arr(arr, 1, n);
    return 0;
}

4、快速排序

#include <iostream>
#include <fstream>
#include <string>

template<typename T>
void swap(T &x, T &y) {
    T temp = x;
    x = y;
    y = temp;
}

const int maxn = 10005;
int arr[maxn];
int n;


int partition(int *arr, int l, int r) // [l, r]
{
    int key = arr[r];
    int pos = l;
    for (int j = l; j < r; ++j)
    {
        if (arr[j] <= key)
        {
            if (pos != j)
                swap(arr[pos], arr[j]);
            ++pos;
        }
    }
    if (pos != r)
        swap(arr[pos], arr[r]);
    return pos;
}

void quick_sort(int *arr, int l, int r)
{
    if (l >= r)
        return;
    int mid = partition(arr, l, r);
    quick_sort(arr, l, mid - 1);
    quick_sort(arr, mid + 1, r);
}

void print_arr(const int *arr, int l, int r)
{
    for (int i = l; i <= r; ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
int main()
{
    std::ifstream is("in.txt");
    while (is >> arr[++n]);
    --n;
    print_arr(arr, 1, n);
    quick_sort(arr, 1, n);
    print_arr(arr, 1, n);
    return 0;
}

5、计数排序

　　计数排序假设n个输入元素中的每一个都是在0到k区间的一个整数，其中k为某个整数。

#include <iostream>
#include <fstream>
#include <string>

template<typename T>
T max(T &x, T &y) {
    return x >= y ? x : y;
}
template<typename T>
void swap(T &x, T &y) {
    T temp = x;
    x = y;
    y = temp;
}

const int maxn = 10005;
int arr[maxn]; // 输入序列
int b[maxn]; // 输出序列
int c[maxn]; // 计数用

void counting_sort(int *arr, int l, int r)
{
    int k = 0;
    for (int i = l; i <= r; ++i)
    {
        ++c[arr[i]];
        k = max(k, arr[i]);
    }
    for (int i = 1; i <= k; ++i)
        c[i] += c[i - 1];
    for (int i = r; i >= l; --i)
    {
        b[c[arr[i]]--] = arr[i];
    }
}

void print_arr(const int *arr, int l, int r)
{
    for (int i = l; i <= r; ++i)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}
int main()
{
    int n = 0;
    std::ifstream is("in.txt");
    while (is >> arr[++n]);
    --n;
    print_arr(arr, 1, n);
    counting_sort(arr, 1, n);
    print_arr(b, 1, n);
    return 0;
}

6、基数排序

7、桶排序