数据结构（十）常用排序算法（插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序）

以下是我学习 常用排序算法 写的代码,及其注释我个人对排序的理解：

其中包括：
 插入排序 — 有序放到前面，拿无序中第一个数跟有序中的数比较大小，找到合适位置插入；
 希尔排序 — （分组插排、缩小增量排序），当分组的个数为1时就排好了；
 选择排序 — 有序放到前面，临时变量记录无序中最小数的下标，将其值与无序中第一个数交换（最小的记录下，比完交换）；
 堆排序 — 排升序要建大堆，排降序建小堆，向下调整很关键；
 冒泡排序 — 有序放到后面,搬西瓜原理，将无序中最大的往后放（有大的就交换，往后冒泡）；
 快速排序 — 三大步：选基准值，做分割，分治算法；
 归并排序 — 平分数组，分治算法（左右分别归并），合并有序数组。

参考菜鸟教程中的排序算法（其中有动态图解，和各语言写的代码）：
https://www.runoob.com/w3cnote/ten-sorting-algorithm.html

以下C++代码是我参考菜鸟教程，自己整理和编写的：

#include <cstdio>
#include <cstdlib>
#include <algorithm>

using namespace std;

// 先写一个交换函数
void Swap(int array[], int a, int b){
	int t = array[a];
	array[a] = array[b];
	array[b] = t;
	// swap(array[a], array[b]);
}
// 再写一个打印函数
void PrintArray(int array[], int size) {
	for (int i = 0; i < size; ++i) {
		printf("%d ", array[i]);
	}
	printf("\n");
}

// 1.插入排序 --- 有序放到前面，拿无序中第一个数跟有序中的数比较大小，找到合适位置插入；
void InsertSort(int array[], int size){
    for(int i = 1; i < size; ++i){
        int save = array[i];
        int j;
        for(j = i - 1; j >= 0; --j){
            if(array[j] < save){
                break;
            }
            array[j + 1] = array[j];
        }
        array[j + 1] = save;
    }
}
// 2.希尔排序 --- （分组插排、缩小增量排序），当分组的个数为1时就排好了；
void InsertSortWithGap(int array[], int size, int gap) {
	for (int i = gap; i < size; ++i) {
		int save = array[i];
		int j;
		for (j = i - gap; j >= 0; j -= gap) {
			if (array[j] <= save) {
				break;
			}
			array[j + gap] = array[j];
		}
		array[j + gap] = save;
	}
}
void ShellSort(int array[], int size) {
	for(int gap = size / 2; gap > 0; gap /= 2){
		InsertSortWithGap(array, size, gap);
	}
}
// 3.选择排序 --- 有序放到前面，临时变量记录无序中最小数的下标，将其值与无序中第一个数交换（最小的记录下，比完交换）；
void SelectSort(int array[], int size){
	for(int i = 0; i < size - 1; ++i){
		int save = i;
		for(int j = i + 1; j < size; ++j){
			if(array[j] < array[save]){
				save = j;
			}
		}
		Swap(array, i, save);
	}
}
// 4.堆排序 --- 排升序要建大堆，排降序建小堆，向下调整很关键；
void AdjustDown(int array[], int size, int rootIdx) {
	int leftIdx = 2 * rootIdx + 1;
	int rightIdx = 2 * rootIdx + 2;
	if (leftIdx >= size) {
		return;
	}
	int maxIdx = leftIdx;
	if (rightIdx < size && array[rightIdx] > array[leftIdx]) {
		maxIdx = rightIdx;
	}
	if (array[rootIdx] >= array[maxIdx]) {
		return;
	}
	Swap(array, maxIdx, rootIdx);
	AdjustDown(array, size, maxIdx);
}
void HeapSort(int array[], int size){
	for(int i = (size - 2) / 2; i >= 0; --i){
		AdjustDown(array, size - 1, i);
	}
	for (int i = 0; i < size; ++i) {
		Swap(array, 0, size - 1 - i);
		AdjustDown(array, size - 1 - i, 0);
	}
}
// 5.冒泡排序 --- 有序放到后面,搬西瓜原理，将无序中最大的往后放（有大的就交换，往后冒泡）；
void BubbleSort(int array[], int size){
	for(int i = 0; i < size; ++i){
		for(int j = 0; j < size - 1 - i; ++j){
			if(array[j] > array[j + 1]){
				Swap(array, j, j + 1);
			}
		}
	}
}
// 6.快速排序 --- 三大步：选基准值，做分割，分治算法；
int Partition(int array[], int low, int high){
	int pivot = array[low];
	while(low < high){
		while(low < high && array[high] >= pivot){
			--high;
		}
		array[low] = array[high];
		while(low < high && array[low] <= pivot){
			++low;
		}
		array[high] = array[low];
	}
	array[low] = pivot;
	return low;
}
void QuickSort(int array[], int low, int high){
	if(low < high){
		int pivotIdx = Partition(array, low, high);
		QuickSort(array, low, pivotIdx - 1);
		QuickSort(array, pivotIdx + 1, high);
	}
}
// 7.归并排序 --- 平分数组，分治算法（左右分别归并），合并有序数组。
void Merge(int array[], int low, int mid, int high){
	int size = high - low + 1;
	int* a = new int[size];
	int leftIdx = low;
	int rightIdx = mid + 1;
	int i = 0;
	while(leftIdx <= mid && rightIdx <= high){
		a[i++] = array[leftIdx] < array[rightIdx] ? array[leftIdx++] : array[rightIdx++];
	}
	while(leftIdx <= mid){
		a[i++] = array[leftIdx++];
	}
	while(rightIdx <= high){
		a[i++] = array[rightIdx++];
	}
	for(i = 0; i < size; ++i){
		array[low + i] = a[i];
	}
	delete[] a;
}
void MergeSort(int array[], int low, int high){
	if(low >= high){
		return;
	}
	int mid = (high + low) / 2;
	MergeSort(array, low, mid);
	MergeSort(array, mid + 1, high);
	Merge(array, low, mid, high);
}

// 写个测试函数
void Test() {
    int array[] = { 3, 9, 1, 4, 7, 5, 2, 8, 0, 6};
	int size = sizeof(array) / sizeof(array[0]);
	printf("排序前数组：\n");
	PrintArray(array, size);
	//printf("\n排序过程：\n");

	//InsertSort(array, size);
    //ShellSort(array, size);
	//SelectSort(array, size);
	//HeapSort(array, size);
	//BubbleSort(array, size);
	//QuickSort(array, 0, size - 1);
	MergeSort(array, 0, size - 1);

	printf("排序后数组：\n");
	PrintArray(array, size);
}
// 测试
int main(){
	Test();
	return 0;
}