快排非递归/归并排序/排序总结

一、非递归实现快排

        在某些情景下,递归可以利用分治思想,将一个问题转化为多个子问题,再转化为更多个最小规模的子问题。从而帮助我们解决问题。

        但是,递归可能在效率和内存上产生问题。现如今,由于编译器的进一步优化,效率上的问题已经开始可以被接受,但内存上还会产生问题。

        这是因为递归的过程是在栈区上开辟和销毁函数栈帧,如果递归层数过深,(如快排退化为O(N^2))时,就会导致栈溢出(StackOverFlow),使程序崩溃,这就要求我们拥有将递归改成非递归的能力。

        1、按照递归逻辑,利用循环模拟递归的过程,是一种普遍的方法。

        2、利用合适的数据结构,例如栈(Stack)等。
        这是因为,函数递归的过程,变化的实际上是函数的参数,它们各自保存在各自的函数栈帧的相应区域,从而完成相似的工作。当我们使用数据结构时,就要通过合适的数据结构,将这些参数保存下来,并在合适的位置取出,从而模拟出递归的过程。

//  利用栈非递归实现快排,类似于前序遍历
//  栈里保存的是  原来递归中改变的参数
void QuickSortNonR(int* arr, int left, int right)
{
	ST s;
	STInit(&s);

	STPush(&s, right);
	STPush(&s, left);

	while (!STEmpty(&s))
	{
		// 取两次栈顶元素,作为接下来排序的区间
		int begin = STTop(&s);
		STPop(&s);
		int end = STTop(&s);
		STPop(&s);

		//排序的过程
		int keyi = QSortByPtrs(arr, begin, end);

		// 排序完后,将后续要排序的子区间入栈
		// [begin,keyi-1] [keyi+1,end]
		//  入栈的区间信息要保证是有效的
		//(为了先进行左区间排序,所以让右区间先入栈)
		if (keyi + 1 < end)
		{
			STPush(&s, end);
			STPush(&s, keyi+1);
		}
		if (begin < keyi-1)
		{
			STPush(&s, keyi-1);
			STPush(&s, begin);
		}

	}
	STDestroy(&s);
}

快速排序的非递归过程类似于前序遍历的过程。先对现在的位置进行排序,然后对左子区间和右子区间分别递归。

具体过程为:root0->rootL1->rootL2……->rootLN,先把左子树的根全部遍历完,然后再对rootLN的左右叶子排序,但由于左右叶子没有数据,直接返回。

快排非递归/归并排序/排序总结_第1张图片

通过递归展开图,我们可以清楚的知道需要保存的参数是left和right。

由于我们习惯上的前序遍历是  root->left->right,而我们使用的数据结构是栈,因此对于先排序的left,就要后入栈,后取出的right就要先入栈。

快排非递归/归并排序/排序总结_第2张图片

先创建一个栈s,并初始化,由于一开始为空栈,先将初始的right和left入栈。

快排非递归/归并排序/排序总结_第3张图片 

 只要栈不为空,就可以进行非递归排序。

分别用begin和end取出之前入栈的left和right(left在right上面,因此先取出)。取出后不要忘了Pop掉,以便取出下一个数据。

取出后,调用之前快排的部分函数,完成对[left,right]区间的排序,并且返回排好位置的下标keyi。

此时相当于完成了root位置的访问,即排序。

然后为了模拟后续左右子树的递归过程,又需要将新的参数入栈。

此时keyi将整个数组分为2个区间。[begin,keyi-1]  [keyi+1,end]。根据先进后出和后进先出原则,仍然是右边先进,即按照 end  keyi+1  keyi-1  begin的顺序入栈。

注意:入栈的时候最好判断一下区间是否存在(相当于递归时判断返回值),如果区间不存在还入栈,下一轮又取出,影响效率,直接不让它入栈即可。

总结:快排的非递归类似于前序遍历,通过对目前根位置排序,得到keyi,然后可以得到两个区间[begin,keyi-1]  [keyi+1,end],再利用栈将区间的参数保存,然后按照入栈出栈的顺序约束,一步一步访问到叶子,利用分治思想,完成整体的排序。

二、归并排序介绍

首先,先了解一下归并的过程。即将两组数据arr1和arr2,它们各自均为升序(假设目标为升序)

然后开辟一个临时数组tmp,从它们各自的第一个元素开始比较,较小的那个就往tmp数组里放,直到其中一个数组全部被拷贝完。然后再将另一个数组中的后续升序部分拷贝的tmp中,则此时tmp就是arr1和arr2归并后的结果。

快排非递归/归并排序/排序总结_第4张图片

快排非递归/归并排序/排序总结_第5张图片 

上图为一次归并排序的内部过程。利用 i  begin1  begin2  三个指针/下标  标记在3个数组中的位置,然后进行比较+拷贝的过程。

快排非递归/归并排序/排序总结_第6张图片 

         与快排的前序遍历不同,归并排序需要先保证左右区间均为有序,因此需要先对其左右子区间进行归并排序,最后再对根位置排序,类似于后续遍历的过程。

一直分解区间,直到剩下1个数据(类比堆排序,无数据时可认为是大堆/小堆),此时1个数据可认为是升序/降序。然后进行 1-1归并,归并完变成有2个数据的有序区间。然后再2-2归并,4-4归并,直到整个数组完全归并。

        下面为动图:

快排非递归/归并排序/排序总结_第7张图片

快排非递归/归并排序/排序总结_第8张图片

归并的过程为标准的二分,共有logN层,每层N个,时间复杂度为O(NlogN) 

 三、递归实现归并排序

//递归实现归并排序的 子函数
void _MergeSort(int* arr, int* tmp, int begin, int end)
{
	if (begin >= end)
		return;

	//归并前先保证左右子区间都有序
	// [begin,mid]  [mid+1,end]
	int mid = (begin + end) / 2;
	_MergeSort(arr, tmp, begin, mid);
	_MergeSort(arr, tmp, mid+1, end);

	//  归并排序的过程
	int i = begin;// 不能给0,要从起始位置开始
	int begin1 = begin;
	int begin2 = mid + 1;
	int end1 = mid;
	int end2 = end;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	// 其中一个数组已经完全归并完了,再把另一个给归并
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}
	//  最后再将tmp数组中的数据拷贝回要排序的arr数组
	//memmove(arr, tmp, sizeof(int) * (end - begin + 1));
	memcpy(arr + begin, tmp+begin, sizeof(int) * (end - begin + 1));


}
//递归实现归并排序
void MergeSort(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (NULL == tmp)
	{
		perror("malloc fail");
		return;
	}
	// 为了避免多次malloc,在此函数中不递归
	// 创建一个子函数,递归子函数,使用的是此函数中malloc的数组
	_MergeSort(arr, tmp, 0, n-1);

	free(tmp);
}

实际上,我们的归并排序,是将一个数组分为两个区间,再看作是2个数组。

对于每个1-1归并的最小规模子问题,我们应该开辟一个大小为2的数组来保存它们排序后的结果,但这样一来,我们就需要开辟N^2级别个数组,由于malloc开辟过程中的损耗,我们选择直接开一个有n个数据的数组tmp,后续的递归拷贝过程用下标来控制。

快排非递归/归并排序/排序总结_第9张图片

找到中间位置mid,然后二分为左右区间,(二分是为了保证递归深度最小,防止栈溢出),对左右区间分别调用归并排序。

 

直到递归区间只有1个数据(默认为有序),或区间不存在时返回。

快排非递归/归并排序/排序总结_第10张图片 

然后对该区间进行归并排序。

用begin1、end1、begin2、end2代表 [begin,mid] [mid+1,end]这两个区间。

 

 之前归并时拷贝到了tmp临时数组,最后一步再拷贝回原arr数组。

注意:拷贝的起始位置是由区间下标标记的,要拷贝到正确的位置上。

        下面给出一张参照图。

快排非递归/归并排序/排序总结_第11张图片

 归并到tmp数组的范围是[begin,end],因此拷贝回arr数组的范围也应该是[begin,end]。

快排非递归/归并排序/排序总结_第12张图片

四、非递归实现归并排序

由于归并排序的递归逻辑为后序遍历,因此无法像快排那样利用栈来模拟实现。因为在归并排序前,要先保证其左右子区间均有序。

因此,前n-1层都不能直接排序,只能先排最后一层,然后从下到上,依次排序。

快排非递归/归并排序/排序总结_第13张图片

先将数据分解为单个有序,然后对所有数据进行1-1排序,然后2-2排序,直到排序完。(这个过程可以通过循环控制,其中gap为要排序的单组数据的个数)。

//非递归实现归并排序
void MergeSortNonR(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (NULL == tmp)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;

	while (gap

 i从0,即第一个位置开始,每次begin1=i,由于一组有gap个数据,所以end1=begin1+gap-1,然后begin2=begin1+gap,end2=end1+gap。

每次循环后,i+=2*gap,再进行后面2组的归并排序,直到将整个数组都排完,此时1-1排序以及全部完成。

gap*=2,进行下一轮的2-2排序,只要gap

快排非递归/归并排序/排序总结_第14张图片

 在每次归并前,我们先将归并区间打印一下。

快排非递归/归并排序/排序总结_第15张图片

对于 10  6  7  1  3  9  4  2  5这样的9个数据,下标的范围应该是[0,8] 

但在打印的过程中,我们可以看到9  10  11  12  15等下标,这些下标是越界的。

这是因为,在完成一轮排序后,我们总是默认将gap变为2倍,然后对begin1、begin2、end1、end2进行gap关系上的赋值,因此,在数据总数N不为2,4,8,16……的2的倍数时,必然会发生越界,越界包括后面的访问和拷贝过程。

为了,防止越界,我们需要在排序前,对下标进行修正。

快排非递归/归并排序/排序总结_第16张图片

 由于begin1的值就是i,而i始终

1、end1越界:此时arr1数组部分在界内,且有序,arr2数组[begin2,end2]完全在界外,因此可以不进行归并排序,直接保留界内的arr1数组。

2、begin2越界:此时arr1数组都在界内,且有序,arr2数组完全在界外,与1相同,不进行归并排序,直接保留所有的arr1数组。

3、end2越界:此时arr数组都在界内,且有序;arr2数组部分在界内,内部有序,还有部分在界外,有序arr1和arr2的部分  只是内部有序,因此需要对arr1和arr2的界内部分进行归并排序,需要对end2进行修正,改为n-1。 

修正后arr1范围仍为[begin1,end1],而arr2的范围变为[begin2,n-1]。

快排非递归/归并排序/排序总结_第17张图片

 添加了修正部分。前2种情况,直接不进行这2组归并,跳出到下一轮gap更大的归并过程中。

end2大于n时,将其修正为n-1,然后进行归并排序。

快排非递归/归并排序/排序总结_第18张图片

拷贝过程是任何一次归并排序后直接拷贝,无论是1-1归并还是2-2归并,都要拷贝先拷贝回arr数组,这是为了便于前面的break,可以直接跳出,不用再重复先拷贝到tmp, 又拷贝回arr的过程。

由于在任何一次归并排序中,i的位置不变,而begin1和begin2都会改变,要拷贝回arr+i,即这段区间的初始位置,拷贝总数为end2-i+1.

五、非比较排序--计数排序

对于我们之前讲的快排,归并排序,希尔排序等,都是通过比较2个数据的大小,来确定它们的相对位置的。

而计数排序通过以下规则实现:

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

通过个数的统计,进行拷贝,不需要比较。

//计数排序
void CountSort(int* arr, int n)
{
	int min = arr[0];
	int max = arr[0];

	for (int i = 1; i < n; ++i)
	{
		if (arr[i] < min)
		{
			min = arr[i];
		}
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	// 先找出来最大值和最小值,确定数据范围
	int range = max - min + 1;
	//计数数组 countA,记录每个数据出现的次数
	int* countA = (int*)calloc(range, sizeof(int));//前面的参数为个数,后面为每个的大小
	if (NULL == countA)
	{
		perror("calloc fail");
	}

	for (int i = 0; i < n; ++i)
	{
		countA[arr[i] - min]++;
	}
	//记录完每个数据出现的次数后,拷贝到原来的数组
	//  排序回原数组的过程
	int j = 0;

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

	free(countA);
}

计数排序的特性总结:
1. 计数排序在数据范围集中时,效率很高,但是适用范围及场景有限。
2. 时间复杂度:O(N+range)
3. 空间复杂度:O(range)

快排非递归/归并排序/排序总结_第19张图片

快排非递归/归并排序/排序总结_第20张图片 

 

 

 

你可能感兴趣的:(数据结构-C,算法,数据结构,c语言,排序算法)