高阶排序实现

一、希尔排序

void shellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)//循环结束时保证gap为1
	{
		//+1是为了防止n不是3的倍数时 gap最终变成0的情况
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int tmp = a[i + gap];
			int j;
			//将i + gap位置上的元素插入到[0, i]间隔为gap的有序区间中
			for (j = i; j >= 0; j -= gap)
			{
				if (tmp >= a[j])
					break;
				a[j + gap] = a[j];
			}
			a[j + gap] = tmp;
		}
	}
}

二、快速排序

/*
三数取中：为了防止最坏情况(数组已经有序)O(n^2)的效率 需要进行的优化 
每轮排序中在最左边、最右边、和中间元素中选出中间值 然后与最左边元素进行交换 作为该轮排序中的key
这样一来 每轮排序key都不会是区间中的最值
*/
int midIndex(int* a, int begin, int end)
{
	int mid = (begin + end) >> 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[end] < a[begin])
			return begin;
		else
			return end;
	}
	else// a[begin] >= a[mid]
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

void quickSort(int* a, int begin, int end)//递归(左右指针法)
{
	if (begin >= end)
		return;
	int mid = midIndex(a, begin, end);//获取三数中间值的下标
	int key = begin;//将当前区间最左边的元素看作key
	Swap(&a[key], &a[mid]);//将中间值交换到最左边作为key
	int left = begin, right = end;
	while (left < right)
	{
		//right找小
		while (left < right && a[right] >= a[key])
			right--;
		//left找大
		while (left < right && a[left] <= a[key])
			left++;
		Swap(&a[left], &a[right]);
	}
	Swap(&a[key], &a[left]);
	key = left;
	//将key位置处的元素看作根 key的左右两边看作左右子树 利用先序遍历进行排序
	quickSort(a, begin, key - 1);
	quickSort(a, key + 1, end);
}

void quickSort(int* a, int begin, int end)//非递归(利用栈)
{
	if (begin >= end)
		return;
	Stack stack;
	initStack(&stack);
	stackPush(&stack, begin);
	stackPush(&stack, end);
	while (!stackEmpty(&stack))
	{
		int right = stackTop(&stack);
		stackPop(&stack);
		int left = stackTop(&stack);
		begin = left;
		end = right;
		stackPop(&stack);
		int key = begin;
		int mid = midIndex(a, begin, end);
		Swap(&a[key], &a[mid]);
		while (left < right)
		{
			while (left < right && a[right] >= a[key])
				right--;
			while (left < right && a[left] <= a[key])
				left++;
			Swap(&a[left], &a[right]);
		}
		Swap(&a[key], &a[left]);
		if (end > left + 1)//右区间元素个数大于1
		{
			stackPush(&stack, left + 1);
			stackPush(&stack, end);
		}
		if (begin < left - 1)//左区间元素个数大于1
		{
			stackPush(&stack, begin);
			stackPush(&stack, left - 1);
		}
	}
}

三、归并排序

void mergeSort(int* a, int begin, int end)//非递归
{
	if (begin >= end)
		return;
	int n = end - begin + 1;
	int* tmp = (int*)malloc(n * sizeof (int));
	if (tmp == NULL)
	{
		printf("mergeSort: malloc failed\n");
		return;
	}
	int gap = 1;
	//如果这里写gap <= n / 2 当数组元素个数为奇数时gap可能会少迭代一次
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//第二个区间不存在(此时无论第一个区间是否完整都不用归并了)
			if (i + gap >= n)
				break;
			int curL = i, curR = i + gap;
			int endL = i + gap - 1, endR = i + 2 * gap - 1;
			//如果第二个区间不完整 需要对第二个区间的边界进行修正
			if (endR >= n)
				endR = n - 1;
			int j = i;
			while (curL <= endL && curR <= endR)
			{
				if (a[curL] < a[curR])
					tmp[j++] = a[curL++];
				else
					tmp[j++] = a[curR++];
			}
			while (curL <= endL)
			{
				tmp[j++] = a[curL++];
			}
			while (curR <= endR)
			{
				tmp[j++] = a[curR++];
			}
			//tmp数据拷贝回原数组
			for (j = i; j <= endR; j++)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;
	}
	free(tmp);
}