常见排序算法

1 希尔排序

void xierSort(int q[], int n) {
    for (int k = n / 2; k >= 1; k --) { // 一种简略的写法, 也可以将距离数组当作参数传入
        for (int i = k; i < n; i ++) { 
        int tem = q[i];
        int j = i - k; 
        for (; j >= 0 && q[j] > tem; j -= k) {
            q[j + k] = q[j];   
        }
        q[j + k] = tem;
        }
    }
}

时间复杂度O(n^2)
2 归并排序

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e6 + 10;
int q[N];
int help[N];
void merge(int q[], int l, int mid, int r) {
    int i = l, j = mid + 1;
    int cnt = 0;
    while (i <= mid && j <= r) {
        if (q[i] < q[j]) help[cnt ++] = q[i ++];
        else  help[cnt ++] = q[j ++];
    }
    while (i <= mid) help[cnt ++] = q[i ++];
    while (j <= r) help[cnt ++] = q[j ++];
    
    for (int j = l, k = 0; k < cnt; k ++, j ++) q[j] = help[k];
}
void merge_sort(int q[], int l, int r) {
    if (l >= r) return;
    int mid = l + r >> 1;
    merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
    merge1(q, l, mid, r);
    
}

时间复杂度O(nlogn)

3 插入排序

void insert_sort(int q[], int n) {
    for (int i = 1; i < n; i ++) {
        int j = i - 1;
        int tmp = q[i];
        for (; j >= 0 && q[j] > tmp; j --) q[j + 1] = q[j];
        q[j + 1] = tmp;
    }
}

时间复杂度O(n^2)

4 选择排序

void choose_sort(int q[], int n) {
    for (int i = 0; i < n; i ++) {
        int index, j;
        index = j = i;
        for (; j < n; j ++)
            if (q[j] < q[index]) index = j;
        if (i != j) swap(q[i], q[index]);
    }
}

时间复杂度O(n^2)

5 快速排序
版本1

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j) {
        do i ++; while (q[i] < x);
        do j --; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

版本2(执行效率不如版本1)

void quick_sort(int q[], int l, int r){
    int temp;
    int i = l, j = r;
    if (l < r) {
        temp = q[l];
        while (i < j) {
            while (j > i && q[j] >= temp) j --;
            if (i < j) q[i] = q[j], i ++;
            while (i < j && q[i] < temp) i ++;
            if (i < j) q[j] = q[i], --j;
        }
        q[i] = temp;
        quick_sort(q, l, i - 1);
        quick_sort(q, i + 1, r);
    }
}

时间复杂度O(nlogn)
6 起泡排序

void bubble_sort(int q[], int n) {
    for (int i = 0; i < n; i ++) {
        for (int j = 0; j < n - i - 1; j ++) {
            if (q[j] > q[j + 1]) swap(q[j + 1], q[j]);
        }
    }
}

时间复杂度O(n^2)

7 堆排序

void down(int u, int n) {
    int t = u;
    if (u * 2 < n && q[u * 2] > q[t]) t = u * 2;
    if (u * 2 + 1 < n && q[u * 2 + 1] > q[t]) t = u * 2 + 1;
    if (u != t) swap(q[u], q[t]), down(t, n);
}
void heap_sort(int q[], int n) {
    for (int i = n / 2; i >= 0; i --) down(i, n);
    for (int i = n - 1; i > 0; i --) swap(q[0], q[i]), down(0, i);
}

时间复杂度O(nlogn)

8 折半插入排序

void BinaryInsertSortdown()
{
	int i,j,x,m;     
	int low,high;    
	for (i = 1; i < n; i++)
	{
		x = q[i];
		low = 0;    
		high = i-1; 
		while (low <= high)
		{
			m = (low + high)/2;
			if (x >= q[m])
			{
				low = m + 1;
			}
			else
			{
				high = m - 1;
			}
		}
		for (j = i-1;j > high; j--)
		{
			q[j + 1] = q[j];
		}
		q[j + 1] = x;
	}
}
原文链接：https://blog.csdn.net/weixin_42245157/article/details/80458542

时间复杂度O(n^2)

关于算法的稳定性：
稳定的定义 ：相同关键词排序后的相对顺序不变。
非稳定算法 快 希尔 选择 堆 都是不稳定的算法 （助记：考研复习痛苦，情绪不稳定，快些选一堆好友来聊天吧！ – 出自天勤数据结构）
为应付考试准备，还有很多优化没做，和边界没有处理，后续有时间完善。