归并排序/计数排序

1：归并排序

1.1：代码

void _MergeSort(int* arr, int left, int right, int* tmp)
{if (left >= right){return;}int mid = (left + right) / 2;						_MergeSort(arr, left, mid, tmp);					_MergeSort(arr, mid+1, right, tmp);					int begin1 = left;									int end1 = mid;										int begin2 = mid + 1;								int end2 = right;									int i = begin1;										while (begin1 <= end1 && begin2 <= end2)			{													if(arr[begin1] < arr[begin2])					{												tmp[i++] = arr[begin1++];					}												if (arr[begin1] > arr[begin2])					{												tmp[i++] = arr[begin2++];					}												}													while (begin1 <= end1)								{													tmp[i++] = arr[begin1++];						}													while (begin2 <= end2)								{													tmp[i++] = arr[begin2++];						}													for (int i = left; i <= right; i++)					{													arr[i] = tmp[i];								}										    
}void MergeSort(int* arr, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);	_MergeSort(arr, 0, n - 1, tmp);
}

1.2：递归过程

图一：

	if (left >= right){return;}int mid = (left + right) / 2;						_MergeSort(arr, left, mid, tmp);					_MergeSort(arr, mid+1, right, tmp);		

通过这三行代码，可以得到如图所示的结果，当传递的 left 和 right 满足 if 条件时，递归开始返回,

图二：

注：方框内容为自定义函数：void _MergeSort(int* arr, int left, int right, int* tmp)

注：对于新手（编者我而言）需要知道的是，每次递归，都会向系统开辟新的空间，而原先的空间会临时贮存在空间中，通过return返回重新调用该函数。

第一次返回时，来到D这个位置，接下来就将执行排序，即如下代码：该函数中 left = 0  mid = 0 right = 1，是对两个元素进行排列。

int begin1 = left;						
int end1 = mid;							
int begin2 = mid + 1;					
int end2 = right;						int i = begin1;							
while (begin1 <= end1 && begin2 <= end2)
{										if(arr[begin1] < arr[begin2])		{									tmp[i++] = arr[begin1++];		}									if (arr[begin1] > arr[begin2])		{									tmp[i++] = arr[begin2++];		}									
}										while (begin1 <= end1)					
{										tmp[i++] = arr[begin1++];			
}										
while (begin2 <= end2)					
{										tmp[i++] = arr[begin2++];			
}										

当前范围内的数组排列完毕时，需要将临时数组的值传递给原数组，以便于下一次继续比较排序，

代码如下：

for (int i = left; i <= right; i++)	
{									arr[i] = tmp[i];				
}									

left 和 right 分别对应数组左右临界，而left ~ right 中间的范围正是需要赋值的对象。

当D排序完毕后，系统会将其释放，此时来到B处，开始对右边数组开始递归，直至return，与左边递归类似，如图三所示：

图三：

当D中和E中的数组全部排列完毕，并且赋值给原数组时，此时会返回到B，对B中数组元素进行排列，，最后我们能够得到如下图所示的结果：

图四：

到B中函数排列完毕，并将临时数组中的值赋值给arr时，此时系统会将其空间释放，并返回到A中，开始递归右边部分函数，其过程如下图所示。

图五：

而对于右半部分的递归与左半部分相似，对于新人而言（我）注意其左临界值left的变化即可，其次通过上述过程不难发现，归并排序其实是一个后序遍历二叉树结点的过程，通过对左右子节点中的数组元素进行排列，最终在根节点处再次排列得到有序数组。

1.3：归并排序特性总结

时间复杂度：O(nlogn)

空间复杂度：O(n) —— 至于为什么是 n 而不是 logn 是因为以malloc 开辟了一块 n 大小的内存空间

2：计数排序

2.1：代码

void CountSort(int* arr, int n)		
{									int max, min;max = min = arr[0];for (int i = 0; i < n; i++){if (arr[i] > max){max = arr[i];}if (arr[i] < min){min = arr[i];}}int range = max - min + 1;int* tmp = (int*)malloc(sizeof(int) * range);assert(tmp);memset(tmp, 0, sizeof(int) * range);for (int i = 0; i < n; i++){tmp[arr[i] - min]++;}int index = 0;for (int i = 0; i < range; i++){while (tmp[i]--){arr[index++] = i + min;}}							
}			

2.2：思路

计数排序的思想：先找到数组中的最大值和最小值，定义 range (range = max - min +1) 个大小空间的数组 ,为了是大数据能够更好的存放进数组，同时又不会浪费太多空间。

我们需要把原数组的数据 - min 存放进新数组相应位置处，原数组中每重复一个数字，新数组相应位置处的大小就+1，这就意味着计数排序要求原数组中，各个数据相差不是很大，否则会造成空间的浪费。

计数排序的巧妙在于，我们不用去比较各个元素然后排序，而是统计原数组中，每个元素出现的次数，并将该元素 - min （这个差对应新数组下标）存入到数组中，如果两个值相差不大 ,得到的差会对应于新数组的一个下标，即新数组中，统计的是该元素在原数组中出现的次数，最后我们再进行排序时，以新数组元素个数为条件出发，同时新数组下标+min 又可以得到原数组中的元素，从而实现排列。

2.3：代码分析

下列代码我们开辟了一块 range 大小的空间区域

	int max, min;max = min = arr[0];for (int i = 0; i < n; i++){if (arr[i] > max){max = arr[i];}if (arr[i] < min){min = arr[i];}}int range = max - min + 1;int* tmp = (int*)malloc(sizeof(int) * range);assert(tmp);memset(tmp, 0, sizeof(int) * range);

下列代码统计了原数组中，每个元素出现的次数，并存入到临时数组中

for (int i = 0; i < n; i++)
{tmp[arr[i] - min]++;
}

最后对临时数组进行访问，以临时数组中元素个数为条件，临时数组下标地址 + min 得到原数组的值：

int index = 0;
for (int i = 0; i < range; i++)
{while (tmp[i]--){arr[index++] = i + min;}
}		

2.4：图示上述过程：

初始时如图所示：

当进入第二个for循环时，开始统计原数组中的元素个数，当循环结束时，得到如下图所示变量关系：

当进入第三个for循环时，遍历tmp中各个元素，同时内层以各个元素的值作为条件，循环的将 i + min （原数组对应值） 赋值给原数组中，当外层 for 循环完成对数组的遍历时，此时原数组也得到了正确的顺序。

2.5：计数排序的特性

适用范围：数据范围比较集中时，效率很高

时间复杂度：O(N+range)

空间复杂度：O(range)