排序算法：交换、选择、归并、基数（桶）、计数、插入

一、排序类别

1、交换排序

（1）冒泡排序

（2）快速排序

2、选择排序

（1）简单选择排序

（2）堆排序

3、归并排序

（1）二路归并

（2）多路归并

4、基数排序（分配、收集多次交替）

（1）最低位优先、最高位优先（在纯数值排序时一般不用）

（2）单关键字排序、多关键字排序（如排若干张扑克牌，有花色、面值两种关键字，需要两种桶，13个面值桶，4个花色桶）

5、计数排序

6、插入排序

（1）直接插入

（2）折半插入

（3）希尔排序

 

二、排序性能

1、复杂度

    n：          计数排序

    m(n+k)： 桶排序（最大位数*（规模+关键字个数））

    n*n：       冒泡、简单选择、插入排序、折半插入

    nlog(n)： 快排、堆排、归并

2、稳定性

    稳定：      冒泡、归并、基数、直接插入

    不稳定：   快排、简单选择、堆排、折半插入

 

三、手写代码

1、快速排序（先排，再分）（双指针对撞）

版本一

void quickSort(vector<int> &num, int low, int high)
{
	if (low >= high) return;

	int p = num[low];                     //枢轴
	int l = low, r = high;                //左指针，右指针
	while (l < r)
	{
		while (l < r && num[r] >= p)      //右指针左移，找到一个比枢轴小的右值
			--r;
		num[l] = num[r];                  //右值 填充到 左指针位置
		while (l < r && num[l] <= p)      //左指针右移，找到一个比枢轴大的左值
			++l;
		num[r] = num[l];                  //左值 填充到 右指针位置
	}
	num[l] = p;                           //左指针l=右指针r，枢轴填入对撞处

	quickSort(num, low, l - 1);
	quickSort(num, l + 1, high);
}

版本二

void quickSort(vector<int> &num, int low, int high)
{
	if (low >= high) return;

	int p = num[low];                     //枢轴
	int l = low, r = high;                //左指针，右指针
	while (l < r)
	{
		while (l < r && num[r] >= p)      //右指针左移，找到一个比枢轴小的右值
			--r;
		if(l < r)
		    num[l++] = num[r];                  //右值 填充到 左指针位置，左指针先右移一位

		while (l < r && num[l] <= p)      //左指针右移，找到一个比枢轴大的左值
			++l;
		if(l < r) 
		    num[r--] = num[l];                  //左值 填充到 右指针位置，右指针先左移一位
	}
	num[l] = p;                           //左指针l=右指针r，枢轴填入对撞处

	quickSort(num, low, l - 1);
	quickSort(num, l + 1, high);
}

2、归并排序（先分，再合）（双指针赛跑）

void merge(vector<int> &num, int low, int mid, int high)
{
    vector<int> temp;
    int i = low, j = mid + 1;

    while(i <= mid && j <= high)
    {
        if(num[i] <= num[j]) temp.push_back(num[i++]);
        else                 temp.push_back(num[j++]);
    }
    while(i <= mid)  temp.push_back(num[i++]);
    while(j <= high) temp.push_back(num[j++]);

    for(int k = low; k <= high; k++)
    {
        num[k] = temp[k-low];
    }
}

void mergeSort(vector<int> &num, int low, int high)
{
    if (low >= high) return;

    int mid = (low + high) / 2;
    
    //先分，分到不能再分，即直接跳过这两句，去执行 merge
    mergeSort(num, low, mid);
    mergeSort(num, mid + 1, high);

    //再合
    merge(num, low, mid, high);
}

3、冒泡排序

//冒泡
void bsort(vector<int> &num)
{
	int n = num.size();
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - 1 - i; j++)
		{
			if (num[j] > num[j + 1])
			{
				swap(num[j], num[j + 1]);
			}
		}
	}
}