常见5种排序（交换、选择、插入、归并、基数）

---

交换排序

通过交换元素的形式进行排序

冒泡排序

思路：通过不断相邻两个元素使之有序，直到不再交换为止。

#include <assert.h>

void Swap(int* a, int* b) {
    assert(a);
    assert(b);
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void BubbleSort(int* a, int n) {
    assert(a);
	for (int i = 0; i < n - 1; i++) {
		int flag = 0;
		for (int j = 0; j < n - 1 - i; j++) {
			if (a[j] > a[j + 1]) {
				flag = 1;
				Swap(a + j, a + j + 1);
			}
		}
		if (flag == 1)
			break;
	}
}

快速排序

思路：按照目标区域相对一个元素的其他元素相对大小分别放在这个元素的左右两端，即确定该元素在这个目标区域中的有序位置。区域被不断细分，直到每个区域都只有一个元素为止。

//快排：前后指针法
#include <assert.h>

void Swap(int* a, int* b) {
	assert(a);
	assert(b);
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int* GetMidIndex(int* left, int* right) {
	assert(left);
	assert(right);
	assert(left <= right);
	int* mid = left + (int)(right - left);
	if ((*left - *mid) * (*left - *right) <= 0)
		return left;
	else if ((*mid - *left) * (*mid - *right) <= 0)
		return mid;
	else
		return right;
}

int* PartSort(int* left, int* right) {
	assert(left);
	assert(right);
	assert(left <= right);
	int* key = GetMidIndex(left, right);
	int* prev = left, * cur = left + 1;
	while (cur <= right) {
		if (*cur < *key && ++prev != cur)
			Swap(cur, prev);
		cur++;
	}
	Swap(key, prev);
	return prev;
}

void QuickSort(int* begin, int* end) {
	assert(begin);
	assert(end);
	assert(begin <= end);
	if (begin == end)
		return;
	int* meet = PartSort(begin, end);
	QuickSort(begin, meet - 1);
	QuickSort(meet + 1, end);
}

---

选择排序

普通选择排序

思路：遍历无序元素找出最值，排入有序排列，同时减少无序元素的个数，直到无序元素消失

#include <assert.h>

void Swap(int* a, int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void SelectSort(int* a, int n) {
	assert(a);
	assert(n > 0);
	int* begin = a, * end = a + n - 1;
	while (begin < end) {
		int* min = begin, * max = begin;
		for (int* cur = begin; cur <= end; cur++) {
			if (*cur < *min)
				min = cur;
			if (*cur > *max)
				max = cur;
		}
		if (min > max)
			Swap(min, max);
		Swap(begin++, min);
		Swap(end--, max);
	}	
}

堆排序

思路：无序的全体元素建堆制成二叉树，根必为该无序集合的最值，取出此根加入到有序排列中，对堆调整后出现新根并不断缩小无序范围，直到二叉树消失，最终留下有序排列。

#include <assert.h>

void Swap(int* a, int* b) {
	assert(a);
	assert(b);
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void AdjustDown(int* a, int n, int root) {
	assert(a);
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child + 1] > a[child])
			child++;
		if (a[child] > a[parent])
			Swap(a + child, a + parent);
		else
			break;
		parent = child;
		child = parent * 2 + 1;
	}
}

void HeapSort(int* a, int n) {
	assert(a);
	for (int i = (n - 1 - 1) / 2; i >= 0; i--) {
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end > 0) {
		Swap(a, a + end);
		AdjustDown(a, end, 0);
		end--;
	}
}

---

插入排序

希尔排序

思路：将无序元素逐一插入到一个有序的排列中，直到不存在无序元素。

#include <assert.h>

void ShellSort(int* a, int n) {
	assert(a);
	int gap = n;
	while (gap > 1) {
		gap = (gap / 3 + 1);
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0) {
				if (tmp >= a[end])
					break;
				a[end + gap] = a[end];
				end -= gap;
			}
		}
	}
}

注：当 gap == 1时，也被称之为“直接插入排序”

---

归并排序

思路：每一个有序排列都由两个近似等大的有序排列归并而成

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

void _MergeSort(int* a, int begin, int end, int* tmp) {
	assert(a);
	assert(begin <= end);
	if (begin == end)
		return;

	int mid = (begin + end) >> 1;
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);

	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int cur = begin1;
	while (begin1 <= end1 && begin2 <= end2) {
		if (a[begin1] < a[begin2])
			a[cur++] = a[begin1++];
		else
			a[cur++] = a[begin2++];
	}
	while (begin1 <= end1)
		a[cur++] = a[begin1++];
	while (begin2 <= end2)
		a[cur++] = a[begin2++];

	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}

// 归并排序递归实现
void MergeSort(int* a, int n) {
	assert(a);
	assert(n >= 0);
	if (n == 0)
		return;
	int* tmp = (int*)malloc(n * sizeof(int));
	assert(tmp);
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

归并排序的非递归形式参考层序遍历区间形式实现，代码如下：

#include <stdlib.h>
#include <stdio.h>
#inlcude <string.h>
#include <assert.h>

// 归并排序非递归实现
void MergeSortNonR1(int* a, int n) {
	assert(a);
	assert(n > 0);
	if (n == 1)
		return;
	int* tmp = (int*)malloc(n * sizeof(int));
	assert(tmp);
	int gap = 1;
	while (gap < n) {
		for (int i = 0; i < n; i += 2 * gap) {
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;

			//通过修正成不存在的区间，使得越界访问得以避免
			if (end1 >= n)
				end1 = end2 = n - 1;
			else if (begin2 >= n || end2 >= n)
				end2 = n - 1;

			int cur = begin1;
			while (begin1 <= end1 && begin2 <= end2)
				if (a[begin1] < a[begin2])
					tmp[cur++] = a[begin1++];
				else
					tmp[cur++] = a[begin2++];
			while (begin1 <= end1)
				tmp[cur++] = a[begin1++];
			while (begin2++ <= end2)
				tmp[cur++] = a[begin2++];
		}
		memcpy(a, tmp, n * sizeof(int));
		gap *= 2;
	}
	free(tmp);
}

---

基数排序

思路：统计每个元素的出现次数，再根据排序标准输出序列。

// 计数排序，排序一定区间内的数字
void CountSort(int* a, int n) {
	assert(a);
	assert(n > 0);
	int min = a[0], max = a[0];
	for (int i = 0; i < n; i++) {
		if (min > a[i])
			min = a[i];
		if (max < a[i])
			max = a[i];
	}
	int range = max - min + 1;
	int* count = (int*)malloc(range * sizeof(int));
	assert(range);
	memset(count, 0, range * sizeof(int));
	for (int i = 0; i < n; i++)
		count[a[i] - min]++;
	int cur = 0;
	for (int i = 0; i < n; i++)
		while (count[i]--)
			a[cur++] = i + min;
}