0
点赞
收藏
分享

微信扫一扫

快速排序的非递归实现、归并排序的递归和非递归实现、基数排序、排序算法的时间复杂度

南柯Taylor 2023-07-23 阅读 76

文章目录

快速排序的非递归

void QuickSortNonS(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	STPush(&st, left);
	STPush(&st, right);
	while (!STEmpty(&st))
	{
		int right = STTop(&st);
		STPop(&st);
		int left = STTop(&st);
		STPop(&st);
		int keyi = PastSort1(a, left, right);
		//先入右区间
		if (keyi + 1 < right)
		{
			STPush(&st, keyi + 1);
			STPush(&st, right);
		}
		//再入左区间
		if (keyi - 1 > left)
		{
			STPush(&st, left);
			STPush(&st, keyi - 1);
		}
	}
	STDestory(&st);
}

三数取中法选取key

还可以选择三数取中法来选取key的值,原理是选取不大不小的数使得快速排序的交换次数变少。
代码如下:

//三数取中法选取Key
int GetMidKey(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] <= a[right]&&a[left] <= a[mid] && a[mid] <= a[right])
	{
		return mid;
	}
	else if(a[left]<=a[mid]&&a[left]<=a[right]&&a[left]<=a[mid])
	{
		return right;
	}
	else if (a[right]<=a[mid]&&a[right]<=a[left]&&a[left]<=a[mid])
	{
		return left;
	}
	else if (a[mid] <= a[left] && a[mid] <= a[right] && a[right] <= a[left])
	{
		return right;
	}
	else if (a[mid] <= a[right] && a[mid] <= a[left] && a[left] <= a[right])
	{
		return left;
	}
	else if (a[right] <= a[left] && a[right] <= a[mid] && a[mid] <= a[left])
	{
		return mid;
	}
	else
	{
		return left;
	}
}

快速排序三路划分

//三路划分
//1、最小的在最左边
//2、最大的在最右边
//3、相等的在中间

void QuickSort1(int* a, int begin, int end)
{
	if (begin > end)
	{
		return;
	}
	//三路划分
	int keyi = GetMidKey(a, begin, end);
	Swap(&a[begin], &a[keyi]);
	int key = a[begin];
	int left = begin;
	int right = end;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < key)
		{
			Swap(&a[cur], &a[left]);
			left++;
			cur++;
		}
		else if (a[cur] > key)
		{
			Swap(&a[cur], &a[right]);
			right--;
		}
		else
		{
			cur++;
		}
	}
	//[begin,left-1][left,right][right+1,end]
	QuickSort(a, begin, left-1);
	QuickSort(a, right + 1, end);
}

归并排序的递归

void _MergeSort(int* a, int begin, int end, int* temp)
{
	//递归结束条件
	if (begin >= end)
	{
		return;
	}
	//我们需要分区间进行,把区间可以分为
	//[begin,mid][mid+1,end]
	int mid = (begin + end) / 2;
	//通过后序遍历使得最小的区间有序[0,0][1,1][2,2]……[end-1,end-1][end,end]
	_MergeSort(a, begin, mid, temp);
	_MergeSort(a, mid+1, end, temp);
	//开始处理归并排序,也就是处理二叉树根的排序问题 左右根
	//这里相当于合并两个有序数组
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1<=end1&&begin2<=end2)
	{
		if (a[begin1] < a[begin2])
		{
			temp[i++] = a[begin1++];
		}
		else
		{
			temp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		temp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		temp[i++] = a[begin2++];
	}
	//再把数据拷回去
	memcpy(a+begin, temp+begin,sizeof(int)*(end-begin+1));
}

//归并排序递归算法
void MergeSort(int* a, int n)
{
	//我们需要开辟一个数组
	int* temp = (int*)malloc(sizeof(int) * n);
	//进行递归需要一个子函数
	_MergeSort(a, 0, n - 1, temp);
	free(temp);
}

递归展开图:
在这里插入图片描述

归并排序的非递归

//归并排序非递归
void MergeSortNonS(int* a, int n)
{
	int gap = 1;
	int* temp = (int*)malloc(sizeof(int) * n);
	while (gap < n)
	{
		int j = 0;
		for (int i = 0; i < n; i += gap * 2)
		{
			//第一趟归并排序1数据归并成两个数,
			//第二趟2个数归为4个数
			//第三趟4个数,4和4归并成8个数
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + gap * 2 - 1;
			//一块一块进行拷贝
			/*if (end1 >= n || begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}*/
			//直接修正
			if (end1 >= n)
			{
				end1 = n - 1;
				//不存在的区间
				begin2 = n;
				end2 = n-1;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			else if (begin2 >= n )
			{
				begin2 = n;
				end2 = n - 1;
			}
			printf("[%d %d][%d %d]\n", begin1, end1, begin2, end2);
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					temp[j++] = a[begin1++];
				}
				else
				{
					temp[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				temp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				temp[j++] = a[begin2++];
			}
			//一块一块进行拷贝
			//memcpy(a+i, temp+i, sizeof(int)*(end2-i)+1);
		}
		//直接拷贝
		memcpy(a, temp, sizeof(int) * n);
		gap *= 2;
	}
	free(temp);
}

计数排序

计数排序应用了相对映射的方法
如下图所示:
在这里插入图片描述
代码实现:

//计数排序
void CountSort(int* a, int n)
{
	//首先找出最大值和最小值
	int max = a[0];
	int min = a[0];
	//相对映射
	for (int i = 0; i < n; i++)
	{
		if (max < a[i])
		{
			max = a[i];
		}
		if (min > a[i])
		{
			min = a[i];
		}
	}
	//求出范围
	int range = max - min;
	//开辟一个range大小的数组
	int* temp = (int*)malloc(sizeof(int) * range+1);
	for (int i = 0; i < n;i++)
	{
		temp[i] = 0;
	}
	//统计次数
	for (int i = 0; i < n; i++)
	{
		temp[a[i] - min]++;
	}
	//排序
	for (int i = 0; i < n; i++)
	{
		while (temp[i]--)
		{
			a[i] = i + min;
		}
	}
	free(temp);
}

稳定性

排序算法的时间复杂度

在这里插入图片描述

数据结构的初阶到此为止,高阶数据结构将用C++来描述。

举报

相关推荐

0 条评论