快速排序、归并排序、大顶堆排序、希尔排序代码实现

快速排序 O(n*log2_n) O(log2_n) 不稳定

// 将数组排序并分成两组
int Partition(int a[], int low, int high)
{
	int pivotval = a[low];
	while (low < high)
	{
		//找到比枢轴小的数，放在low位置
		while (low < high&&a[high] >= pivotval)
			high--;
		if (low < high)
		{
			a[low] = a[high];
			low++;
		}
		//找到比枢轴大的数，放在high位置
		while (low < high&&a[low] <= pivotval)
			low++;
		if (low < high)
		{
			a[high] = a[low];
			high--;
		}
		//放置枢轴
		a[low] = pivotval;
	}
	return low;
} 
// 递归调用快速排序
void QSort(int a[], int low, int high)
{
	if (low < high)
	{
		int pivot = Partition(a, low, high);
		QSort(a, low, pivot-1);
		QSort(a, pivot+1, high);
	}
}
// 快速排序 O(n*log2_n) O(log2_n) 不稳定
int QuickSort(int a[], int n)
{
	if (a == NULL || n <= 0)
		return -1;
	QSort(a, 0, n - 1);
	return 0;
}

归并排序 O(n*log2_n) O(n) 稳定

// 归并两数组
void Merge(int a[], int tmp[], int left, int mid, int right)
{
	int i = left, j = mid + 1, k = left;
	//将左右两部分中小的放到tmp中
	while ((i <= mid) && (j <= right))
		tmp[k++] = (a[i] < a[j]) ? a[i++] : a[j++];
	//将左部分剩余的数放到临时数组中
	while (i <= mid)
		tmp[k++] = a[i++];
	//将右部分剩余的数放到临时数组中
	while (j <= right)
		tmp[k++] = a[j++];
	//将临时数组复制到原数组
	while (k > left)
		a[--k] = tmp[k];
}
// 递归调用递归排序
void MSort(int a[], int tmp[], int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MSort(a, tmp, left, mid);
		MSort(a, tmp, mid + 1, right);
		Merge(a, tmp, left, mid, right);
	}
}
// 归并排序 O(n*log2_n) O(n) 稳定
int MergeSort(int a[], int n)
{
	if (a == NULL || n <= 0)
		return -1;
	int *tmp = (int *)malloc(sizeof(int)*n);
	MSort(a, tmp, 0, n - 1);
	free(tmp);
	return 0;
}

大顶堆排序 O(n*log2_n) O(1) 不稳定

// 调整大顶堆
void HeapAdjust(int a[], int i, int n)
{
	//i为当前调整结点的索引，j为当前调整结点的做孩子结点，编号从0开始
	int j = 2 * i + 1;
	int tmp = a[i];
	while (j <= n - 1)
	{
		//取出左右孩子结点较大的索引
		if ((j < n - 1) && (a[j] < a[j + 1]))
			j++;
		//当前结点比其左右孩子结点大，直接退出，调整完毕
		if (tmp >= a[j])
			break;
		//当前结点比其左右孩子结点小，交换两数，并继续往下调整
		a[(j - 1) / 2] = a[j];
		j = 2 * j + 1;
	}
	a[(j - 1) / 2] = tmp;
}
// 大顶堆排序 O(n*log2_n) O(1) 不稳定
int HeapSort(int a[], int n)
{
	if (a == NULL || n <= 0)
		return -1;

	int i, tmp;
	//初始化原数据为一个大顶堆
	for (i = n / 2 - 1; i >= 0; i--)
	{
		HeapAdjust(a, i, n);
	}
	//交换大顶堆的第一个数和最后一个数，即取出大顶堆的最大值放于最后
	//序列长度减少1，重新调整为大顶堆
	for (i = n - 1; i>0; i--)
	{
		tmp = a[i];
		a[i] = a[0];
		a[0] = tmp;
		HeapAdjust(a, 0, i);
	}

	return 0;
}

希尔排序 O(n*log2_n) O(1) 不稳定

// 希尔排序 O(n*log2_n) O(1) 不稳定
int ShellSort(int a[], int n)
{
	if (a == NULL || n <= 0)
		return -1;

	int i, j, k, tmp;
	int gap;
	for (gap = n / 2; gap > 0; gap /= 2)
	{
		for (i = 0; i < gap; i++)
		{
			//内部使用简单插入法排序
			for (j = i + gap; j < n; j += gap)
			{
				tmp = a[j];
				for (k = j; k>i&&a[k - gap]>tmp; k -= gap)
				{
					a[k] = a[k - gap];
				}
				a[k] = tmp;
			}
		}
	}

	return 0;
}