八大排序 详解（中）

接上篇博文——《八大排序 详解（上）》

在这篇博文中本人就不过多解释排序的重要性了，接着是本人上篇博文——《八大排序 详解（上）》来讲，在这篇博文中，本人要进行讲解的是剩下的四大排序——插入排序、希尔排序（插入排序的进阶版）、桶排序以及归并排序

五、插入排序：
插入排序的原理是：
将所需排列的数组分为两半——已排和未排
每次将未排的第一个数取出，然后从已排数组的第一个开始比较，遇到比它大的数，就插到那个数的前面。

那么，我们现在用一张动态图来展示一下这个排序算法：

那么，用代码来实现的结果如下：

void insertSort(int *array, int count) {
	int i;
	int j;
	int t;
	int tmp;

	for (i = 1; i < count; i++) {
		tmp = array[i];
		for (j = 0; j < i && tmp > array[j]; j++)
			;
		for (t = i; t > j; t--) {
			array[t] = array[t-1];
		}
		array[j] = tmp;
	}
}

从这里我们能够发现，插入排序的时间复杂度是O(n ^2)。

六、希尔排序（插入排序的进阶版）：
希尔排序和别的几大排序相比，算是比较中庸那种，因为它的最差情况和最优情况基本没多大差别，它的基本思想如下:
首先，我们将每隔step个数的每个数放在一起，这样分好类之后，再用新的step分组，再进行如上操作（每个step都是数组长度每次除以2所得），直到step为0时结束

现在，我们用一个动态图来实现这个排序算法：

而作为插入排序的进阶版，这个排序算法和插入排序算法的代码都基本一样。
相关代码如下：

static void insertSortOnce(int *array, int count, int start, int step) {
	int i;
	int j;
	int t;
	int tmp;

	for (i = start + step; i < count; i += step) {
		tmp = array[i];
		for (j = start; j < i && tmp > array[j]; j += step)
			;
		for (t = i; t > j; t -= step) {
			array[t] = array[t-step];
		}
		array[j] = tmp;
	}
}

void ShellSort(int *array, int count) {
	int step;
	int start;

	printf("
Shell sort
");
	for (step = count/2; step; step /= 2) {
		for (start = 0; start < step; start++) {
			insertSortOnce(array, count, start, step);
		}
	}
}

这里对上面的代码做下解释：
第一个函数的类型前都有个static，意思是这个函数仅在该文件中使用，我们所编写的函数在接下来的代码中能够发现，提供给用户使用的只是这八大排序，至于构成这八大函数的子函数，不会提供给用户，这也是我们在数据结构与算法专题中要提到的，编写的.h的.c函数能够提供给外部使用的函数，在.h文件中声明；至于不能给外部使用的函数，就在.c文件中声明，我们在未来编程的过程中会了解到我们所做的工具函数和这里一样，并不是把所有的函数都提供给用户使用。

从这里我们能够发现，希尔排序的时间复杂度是O(n ^（1.3 ~ 2）)。

七、归并排序：
归并排序的基本思想是：
分而治之，先两个两个比较，凑齐两组两两排好的组后，再进行四个四个比较，之后就是八个八个...直至比较的范围是整个数组的长度，待排完这轮后就结束排序。

现在，我们通过一张动态图来展示下这个排序算法：

那么，相关代码如下：

static void merge(int* array, int left, int right, int mid, int* temp) {
	int i = left;
	int j = mid + 1;
	int tempLeft = left;
	int t = 0;
	
	while (i <= mid && j <= right) {
		temp[t] = array[i] <= array[j] ? array[i++] : array[j++];
		t++;
	}
	while (i <= mid) {
		temp[t++] = array[i++];
	}
	while (j <= right) {
		temp[t++] = array[j++];
	}								//以上三个循环的目的是将整个数组排好序再存入temp数组中

	t = 0;
	while (tempLeft <= right) {		//这个循环的目的是将排好序的数组内的值赋值给原数组
		array[tempLeft++] = temp[t++];
	}
}

static void mSort(int* array, int left, int right, int* temp) {
	int mid;

	if (left >= right) {
		return;
	}
	
	mid = (left + right) / 2;
	mSort(array, left, mid, temp);
	mSort(array, mid + 1, right, temp);
	merge(array, left, right, mid, temp);

}

void mergeSort(int* array, int count) {
	int *temp;
	
	temp = (int *)calloc(sizeof(int), count);
	mSort(array, 0, count-1, temp);
}

从这里我们能够发现，归并排序的时间复杂度是O(n * log n)。

八、桶排序：
桶排序作为我们八大排序的最后一个来讲，是因为这个排序算法在我看来比较偏激，因为它变相地运用了“用空间换时间”的思想，它的大致原理如下：
首先，我们放置10个桶，分别代表某一位为0~9哪一位的数都有谁，最后将桶中所有数取出放入原数组中，这样就完成了桶排序。

现在，我们通过一张动态图来展示下这个排序算法：

那么，代码如下：

//寻找原数组中的最大值
static int findMaxNum(const int *array, int count) {
	int max = array[0];
	int i;

	for (i = 1; i < count; i++) {
		if (array[i] > max) {
			max = array[i];
		}
	}

	return max;
}

//寻找原数组中的最小值
static int findMinNum(const int *array, int count) {
	int min = array[0];
	int i;

	for (i = 1; i < count; i++) {
		if (array[i] < min) {
			min = array[i];
		}
	}

	return min;
}

void bucketSort(int *array, int count){
	int i = 0;
	int j = 0;
	int max = findMaxNum(array, count);
	int min = findMinNum(array, count);
	int length = max - min;	//通过最大值和最小值 来获取结果“桶”的容量

	int *res = (int *)calloc(sizeof(int), length+1);

	//用 结果数组中的适当下标的单元中的数，来记录垓下标在原数组中的出现次数
	for (i = 0; i < count; i++) {
		res[array[i] - min]++;
	}
 
	//为原数组赋排序后的值
	for(i = 0; i <= length; ++i) {
		while(res[i]--) {
			array[j++] = i + min;
		}
	}
	free(res);
}

我们可以在这里发现，桶排序的其实就是先放入桶中，再从桶中取出，放回原数组，这样下来，时间复杂度为O(n),但是空间复杂度比较高，所以它也算是很偏激那种排序算法，如果对时间需求高，这个排序算法无疑是最好的选择。

那么，到目前为止，我们的八大排序就讲解完成了，希望同学们在看完本人的讲解之后能够有所收获！
关于本人有关排序的最后一篇博文——《八大排序 详解（下）》，将会使用《八大排序 详解（上）》和本篇博文所编写的所有函数，并以一种十分凶悍的方法进行调用函数，也会用到本人之前的博文《指向函数的指针——消费未来》那篇所运用的知识，希望看到这里的同学能够耐心将下篇看完，谢谢！！！

《八大排序 详解（上）》
《八大排序 详解（下）》