常见排序宝典：帮助快速上手常见基础排序算法（下）

void _Merge_sort(int* arr, int begin, int end, int* tmp)
{
	if (begin == end)
	{
		return;
	}//从单个元素开始递归

	int mid = (begin + end) / 2;//划分为两个空间，等待回归
	_Merge_sort(arr, begin, mid, tmp);
	_Merge_sort(arr, mid + 1, end, tmp);

	//开始归并
	int begin1 = begin, end1 = mid;
	int begin2 = end1 + 1, end2 = end;
	int i = begin;//i来记录此次归并开始的位置
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] <= arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	//当两部分有一方出现end大于begin时，退出循环，此时另外一方可能出现数据没完全拷贝回去的情况
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}

	//此时tmp中的数已经排好顺序，需要返回到原数组

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

void Merge_sort(int* arr, int len)//由于我们打算用递归来写，所以最好将递归部分包装出去成为一个接口
{
	//开辟一个同等大小的数组
	int* tmp = (int*)malloc(sizeof(int) * len);
	if (tmp == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}

	_Merge_sort(arr, 0, len - 1, tmp);

	free(tmp);
	tmp = NULL;
}

void Merge_sort(int* arr, int len)//非递归思想
{
	int* tmp = (int*)malloc(sizeof(int) * len);
	if (tmp == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}

	int gap = 1;//gap代表是当前所分两组，每组的元数个数
	while (gap < len)
	{
		for (int i = 0; i < len; i += 2 * gap)
		{
			int begin1 = i, end1 = begin1 + gap - 1;
			int begin2 = begin1 + gap, end2 = begin2 + gap - 1;
			int j = i;

			if (end1 >= len || begin2 >= len)
			{
				break;//判断，小心此次循环出现数据越界
			}
			//还有一种end2越界但是begin2没有越界
			if (end2 >= len)
			{
				end2 = len - 1;
			}

			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					tmp[j++] = arr[begin1++];
				}
				else
				{
					tmp[j++] = arr[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[j++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = arr[begin2++];
			}
			memcpy(arr + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

void AdjustDown(int* arr, int len, int parent)
{
	int child = parent * 2 + 1;
	while (child < len)
	{
		if (child + 1 < len && arr[child] < arr[child + 1])\
		{
			child += 1;
		}
		if (arr[parent] < arr[child])
		{
			Swap(arr[parent], arr[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void Heap_sort(int* arr, int len)
{
	int size = len;
	while (size > 0)
	{
		for (int i = (size - 1 - 1) / 2; i >= 0; i--)
		{
			AdjustDown(arr, size, i);
		}//挑选最大的到堆顶
		Swap(arr[0], arr[--size]);
	}
}

void Swap(int& a, int& b)
{
	int c = a;
	a = b;
	b = c;
}

//快速排序
//hoare版本
void Quick_sort(int* arr, int left, int right)
{
	if (left > right)
	{
		return ;
	}
	int key = left;
	int begin = left, end = right;

	while (left < right)
	{
		while (left < right && arr[right] >= arr[key])//在循环过程中，容易出现分循环一直没找到小于的值，right一直减，让right<小于left的情况
			//所以安排循环条件内加入left<right。a[right]>=a[left]的等于是怕出现相同的值，导致循环断掉，出现卡死循环的情况
		{
			right--;
		}//直到找到一个值小于a[key]

		while (left<right && arr[left]>arr[key])
		{
			left++;
		}

		Swap(arr[right], arr[left]);
	}
	//退出循环时right与left相遇
	Swap(arr[key], arr[left]);
	key = left;//交换之后更新key的值充当分割点坐标进行下面的递归
	Quick_sort(arr, begin, key - 1);
	Quick_sort(arr, key, end);
}

//双指针法
void Quick_sort(int* arr, int left, int right)
{
	if (right <= left)
	{
		return;
	}

	int prew = left, cur = left + 1;
	int keyi = left;

	while (cur <= right)
	{
		if (arr[cur] < arr[keyi] && ++prew != cur)
		{
			Swap(arr[cur], arr[prew]);
		}
		cur++;
	}
	Swap(arr[keyi], arr[prew]);
	keyi = prew;
	Quick_sort(arr, left, keyi - 1);
	Quick_sort(arr, keyi + 1, right);
}

void Count_sort(int* arr, int len)
{
	int min = arr[0], max = arr[0];

	for (int i = 1; i < len; i++)
	{
		if (min > arr[i])
		{
			min = arr[i];
		}
		if (max < arr[i])
		{
			max = arr[i];
		}
	}

	int range = max - min + 1;
	int* tmp = (int*)calloc(range, sizeof(int));
	if (tmp == NULL)
	{
		perror("calloc fail!");
		exit(1);
	}

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

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