基本排序算法简介

一、 排序的定义

所谓排序，就是使一串数据，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。

二、排序的分类

内部排序和外部排序：

​ 内部排序是数据记录在内存中进行排序。

​ 外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

下面要介绍的几种基本排序算法都是内部排序。

稳定排序和不稳定排序：

​ 稳定排序：对于元素相等的比较，排序前后相对位置不变。

不稳定排序：对于元素相等的比较，排序前后相对位置可能发生变化。

​ 简单地说，假设 a == b, 并且a在b前面，如果排序之后a仍然在b的前面，那么该排序算法就是稳定的，如果排序之后 a 可能会出现在 b 的后面，那么该排序算法就是不稳定的。

常见排序算法时间/空间复杂度以及稳定性比较：

时间复杂度：算法的时间复杂度是一个函数，它定性描述该算法的运行时间。

空间复杂度：空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。

直接插入排序：

首先介绍的是插入排序算法。

插入排序是一种非常直观的排序算法，它的基本思想是将线性表分为已排序的前半部分和待排序的后半部分，从待排序部分选出第一个元素，插入到已排序部分的对应位置中，直到全部记录都插入到已排序部分中。

插入排序每次插入的时间复杂度为O(n)，一共执行n - 1次，因此总体时间复杂度为O(n^2)。
在插入时查找插入位置的过程可以使用折半查找算法将查找位置的复杂度优化到O(logn),但因为还需要O(n)的时间复杂度来在顺序表上执行移动操作，所以总体时间复杂度依然是O(n^2)。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define MAX_N 100000

int main() {
    int n, a[MAX_N];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < n; i++) {
        for (int j = i; j > 0 && a[j] < a[j - 1]; j--) {
            swap(a[j], a[j - 1]);
        }
    }
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

冒泡排序：

接下来介绍冒泡排序算法。

和插入排序算法不同，冒泡排序算法是一种基于交换的排序算法。基于交换的排序，是指根据线性表中两个元素关键字的比较结果来对换这两个元素在序列中的位置。

冒泡排序算法的基本思想为:假如待排序线性表的长度为n,从前往后两两比较相邻元素的关键字，若a_i-1> a_i则交换它们，直到线性表比较完成。每趟交换以后最后一个元素一定是最大的， 不再参与下一趟交换。 也就是对于第i趟交换，只需要比较到a_{n- i};即可。直到- -趟比较内没有进行交换，算法结束。时间复杂度和插入排序一一样，也为O(n^2)。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define MAX_N 100000

int main() {
    int n, a[MAX_N];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < n - i; j++) {
            if (a[j] > a[j + 1])
                swap(a[j], a[j + 1]);
        }
    }
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

归并排序：

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将一块待排序的区间，取中间位置，分成两段区间；然后通过不断的递归，直到每段区间只有一个数字，这时我们就认为该段区间有序，然后将这相邻的两段有序区间合并为一个有序区间；

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define MAX_N 100000

void merge_sort(int *a, int l, int r) {
    if (l == r) return ;
    int mid = (l + r) >> 1;
    merge_sort(a, l, mid);
    merge_sort(a, mid + 1, r);
    int t[r - l + 1], x = l, y = mid + 1, z = 0;
    while (x <= mid || y <= r) {
        if (x <= mid && (a[x] <= a[y] || y > r)) {
            t[z++] = a[x++];
        } else {
            t[z++] = a[y++];
        }
    }
    for (int i = l; i <= r; i++) {
        a[i] = t[i - l];               
    }
    return;
}

int main() {
    int n, a[MAX_N];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    merge_sort(a, 0, n - 1);
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

快速排序：

快速排序是目前应用最广泛的排序算法之一。它的基本思想是，每次从待排序区选取一个元素作为基准，所有比基准记录小的元素都在基准记录的左边，而所有比基准记录大的元素都在基准记录的右边。之后分别对基准记录的左边和右边两个区间进行快速排序，直至将整个线性表排序完成。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define MAX_N 100000

void quick_sort(int *a, int l, int r) {
    if (r <= l) return;
    int x = l, y = r, z = a[l];
    while (x < y) {
        while (x < y && a[y] >= z) y--;
        if (x < y) a[x++] = a[y];
        while (x < y && a[x] <= z) x++;
        if (x < y) a[y--] = a[x];
    }
    a[x] = z;
    quick_sort(a, l, x - 1);
    quick_sort(a, x + 1, r);
}

int main() {
    int a[MAX_N], n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    quick_sort(a, 0, n - 1);
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

直接选择排序：

直接选择排序是一种简单的排序算法，是一种不稳定的排序方法，其基本思想是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 即在每一步中选取最小值来重新排列，从而达到排序的目的。

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define MAX_N 100000

int main() {
    int a[MAX_N], n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    for (int i = 0; i < n - 1; i++) {
        int ind = i;
        for (int j = i + 1; j < n; j++) {
            if (a[ind] > a[j]) ind = j;
        }
        swap(a[i], a[ind]);
    }
    for (int i = 0; i < n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}