八大排序算法之归并排序(递归实现+非递归实现)

目录

一.归并排序的基本思想

归并排序算法思想(排升序为例)

二.两个有序子序列(同一个数组中)的归并(排升序)

两个有序序列归并操作代码:

三.归并排序的递归实现

递归归并排序的实现:(后序遍历递归)

递归函数抽象分析: 

四.非递归归并排序的实现

1.非递归归并排序算法思想:

2.算法实现

初步非递归归并排序函数:

一般情况下(所排序数组元素个数不为​编辑)边界条件分析:

经过边界修正后的非递归归并排序函数

排序实测:


一.归并排序的基本思想

  • 归并排序是基于分治思想和归并操作而设计出来的一种高效排序算法
  • 所谓的归并操作就是将两个有序的子序列合并为一个有序序列的操作(归并操作算法时间复杂度O(N+M),N+M分别为两个子数组的元素个数)

归并排序算法思想(排升序为例)

  1. 假设数组有N个元素,先将数组不断地二分,直到将数组划分为N个由单个元素构成的子数组,整个划分过程中所有子数组构成满二叉树(或接近满二叉树)的逻辑结构,如图:
  2. 数组划分完后再逐层向上将二叉树兄弟结点子数组(具有相同前驱结构)两两进行归并操作完成排序:
  3. 归并操作算法时间复杂度O(M1+M2),M1+M2分别为两个子数组的元素个数,因此二叉树一层子数组两两归并操作总时间复杂度为O(N)(N表示原数组的元素个数),而满二叉树层次数量级O(logN),因此归并排序的总体时间复杂度为O(NlogN)
  4. 由于归并排序的数组划分每次都是严格地二分,因此每次排序(无论具体面对怎样的序列)子数组划分结构都是稳定的满二叉树(或接近满二叉树)结构,因此归并排序的时间复杂度各种情况下都不会有变化(不会像快排,希尔排那样由于所处理的序列的逆序数的差异而导致算法时间复杂度有所变化)
  5. 然而由于有序序列归并操作需要额外开辟数组来完成,因此归并排序有较大的空间消耗,这是归并排序的一个缺陷

二.两个有序子序列(同一个数组中)的归并(排升序)

函数首部:

void MergeSort(int* arr,int* tem, int left,int right)

arr是被分割的原数组,tem是用于归并操作的临时数组,left是arr的左端下标,right是arr的右端下标

  • 假设数组arr被二等分为两个子序列(两个子序列都是有序的):
  • 接下来我们将上图中的[left,(left+right)/2)和[(left+right)/2),right)两个子序列(有序)合并到一个tem数组中构成一个新的有序序列(利用三指针操作完成归并):
  • 从算法gif中不难看出,归并操作的时间复杂度两个子数组的元素个数线性关系

两个有序序列归并操作代码:

void MergeSort(int* arr,int* tem, int left,int right)
{
	int mid = left + (right - left) / 2;			//找到数组[left,right]的中间分割点

	int ptr1 = left;								//ptr1指向左子数组的首元素
	int ptr2 = mid;									//ptr2指向右子数组的首元素
	int ptrtem = left;                              //ptrtem用于在tem数组中尾插数据
	while (ptr1 < mid && ptr2 < right)				//ptr1和ptr2其中一个遍历完子数组就停止循环
	{
		//将较小元素尾插进tem数组中
		if (arr[ptr1] > arr[ptr2])
		{
			tem[ptrtem] = arr[ptr2];
			++ptrtem;
			++ptr2;
		}
		else
		{
			tem[ptrtem] = arr[ptr1];
			++ptrtem;
			++ptr1;
		}
	}
	//将未被遍历完的子数组剩下的元素尾插到tem数组中
	while (ptr1 < mid)
	{
		tem[ptrtem] = arr[ptr1];
		++ptrtem;
		++ptr1;
	}
	while (ptr2 < right)
	{
		tem[ptrtem] = arr[ptr2];
		++ptrtem;
		++ptr2;
	}
	
	//将归并好的有序序列拷贝到原数组arr上
	for (int i = left; i < right; ++i)
	{
		arr[i] = tem[i];
	}
}

三.归并排序的递归实现

递归函数首部:

void MergeSort(int* arr,int* tem, int left,int right)

arr是被分割的原数组,tem是用于归并操作的临时数组,left是arr的子数组左端下标,right是arr的子数组右端下标

  • 在进行子数组两两归并之前,我们先要进行数组的二分分治:
  • 我们可以通过分治递归完成数组的整个二分过程(每个子数组的区间端点下标都被存储在递归函数的各函数栈帧中):(数组二分的递归框架)
    void MergeSort(int* arr, int* tem, int left, int right)
    {
    	if (right <= left+1)                  //当子数组只剩一个元素时停止划分
    	{
    		return;
    	}
    	int mid = left + (right - left) / 2;
    	MergeSort(arr, tem, left, mid);      //划分出的左子数组
    	MergeSort(arr, tem, mid, right);     //划分出的右子数组
    
    	//左右子数组都有序后完成左右子数组的归并
    }
  • 观察递归图解,有序序列两两归并的过程只能发生在上图中的第7,第13,第14,第21,第27,第28,第29步骤中,因此整个排序过程满足分治递归的后序遍历逻辑

递归归并排序的实现:(后序遍历递归)

  • 左右子数组(有序)归并的代码段位于函数中两个递归语句之后
void MergeSort(int* arr, int* tem, int left, int right)
{
	if (right <= left+1)                  //当子数组只剩一个元素时停止划分
	{
		return;
	}
	int mid = left + (right - left) / 2;
	MergeSort(arr, tem, left, mid);      //划分出的左子数组
	MergeSort(arr, tem, mid, right);     //划分出的右子数组
    
    
    //后序遍历,归并过程发生在两个递归语句之后
	//左右子数组都有序后完成左右子数组的归并
	int ptr1 = left;								//ptr1指向左子数组的首元素
	int ptr2 = mid;									//ptr2指向右子数组的首元素
	int ptrtem = left;                              //ptrtem用于在tem数组中尾插数据
	while (ptr1 < mid && ptr2 < right)				//ptr1和ptr2其中一个遍历完子数组就停止循环
	{
		//将较小元素尾插进tem数组中
		if (arr[ptr1] > arr[ptr2])
		{
			tem[ptrtem] = arr[ptr2];
			++ptrtem;
			++ptr2;
		}
		else
		{
			tem[ptrtem] = arr[ptr1];
			++ptrtem;
			++ptr1;
		}
	}
	//将未被遍历完的子数组剩下的元素尾插到tem数组中
	while (ptr1 < mid)
	{
		tem[ptrtem] = arr[ptr1];
		++ptrtem;
		++ptr1;
	}
	while (ptr2 < right)
	{
		tem[ptrtem] = arr[ptr2];
		++ptrtem;
		++ptr2;
	}

	//将归并好的有序序列拷贝到原数组arr(相应下标位置)
	for (int i = left; i < right; ++i)
	{
		arr[i] = tem[i];
	}
}
  • 注意细节: 

递归函数抽象分析: 

  • 递归函数MergeSort(arr,tem,left,right)可以抽象为:借助tem数组完成arr数组[left,right)区间序列的排序过程
  • 于是可以抽象出递推公式:MergeSort(arr,tem,left,right) = MergeSort(arr,tem,left,left + (right - left) / 2) + MergeSort(arr,tem,left + (right - left) / 2,right) +{子数组[left,left + (right - left) / 2))和子数组[left + (right - left) / 2,right)的有序合并}
  • 递归公式的含义是:完成arr数组[left,right)区间序列排序的过程可以拆分为如下三个步骤:
  1. 先完成左子区间[left,left + (right - left) / 2)的排序
  2. 再完成右子区间[left + (right - left) / 2,right)的排序
  3. 最后将左右子区间进行归并完成[left,right)区间序列的排序
  • 将MergeSort函数进行一下简单的封装供外界调用:
    void _MergeSort(int* arr, int size)
    {
    	assert(arr);
    	int* tem = (int*)malloc(sizeof(int) * size);
    	assert(tem);
    	MergeSort(arr, tem, 0, size);
        free(tem);
    }
    
  • arr是待排序数组,size是数组的元素个数,MergeSort是归并排序递归函数

四.非递归归并排序的实现

1.非递归归并排序算法思想:

  • 归并排序过程中数组逐步被二分的图示:
  • 归并排序的递归实现通过后序遍历逻辑来完成各个子数组的两两归并的操作: 
  • 然而我们也可以利用类似于层序遍历的逻辑实现子数组两两归并的过程:

从最高层子数组开始进行兄弟子数组的两两归并,完成了一层子数组的归并再继续完成前一层子数组的归并直到最后完成原数组的排序,我们可以通过循环来实现这个过程

2.算法实现

  • 非递归归并排序函数首部:
    void MergeSortNonR(int* arr, int size)

    arr代表待排序的数组,size为待排序数组的元素个数

  • 先假设所处理的数组元素个数:N=2^{n}(即数组刚好能被完全二分n次)
  • gap作为二叉树结构某层次子数组的元素个数:gap初值为1(最深层子数组元素个数为1),随后gap以gap=2*gap的方式递增,用gap来控制排序函数最外层循环:
    	for (int gap = 1; gap < size; gap *= 2)   //完成logN个层次的子数组的归并
    	{
    
    	}

    循环能进行log(size)次,对于每个gap值完成一个层次的子数组的两两归并:

  • 再使用一个变量i来遍历每一个gap情形下各个进行归并的序列组(每个序列组两个子数组构成):

     

    	for (int gap = 1; gap < size; gap *= 2)      //完成logN个层次的子数组的归并
    	{
    		for (int i = 0; i < size; i += 2 * gap)  //i每次跳过一个归并序列组(每个序列组有两个子数组)
    		{
    			//对子数组[i,i+gap)和子数组[i+gap,i+2*gap)进行归并操作
    		}
    	}

     图解:

  • 初步非递归归并排序函数:

    void MergeSortNonR(int* arr, int size)
    {
    	assert(arr);
    	int* tem = (int*)malloc(sizeof(int) * size); //tem数组用于完成归并操作
    	assert(tem);
    
    	
    
    	for (int gap = 1; gap < size; gap *= 2)      //完成logN个层次的子数组的归并
    	{
    		int indextem = 0;						 //用于将数据归并到tem数组中的下标变量
    		for (int i = 0; i < size; i += 2 * gap)  //i每次跳过一个归并序列组(每个序列组有两个子数组)
    		{
    			//对子数组[i,i+gap)和子数组[i+gap,i+2*gap)进行归并操作
    			int begin1 = i;                      //begin1和end1维护一个子数组
    			int end1 = i + gap; 
    			int begin2 = i + gap;				 //begin2和end2维护一个子数组
    			int end2 = i + 2 * gap;
    
    			while (begin1 < end1 && begin2 < end2)
    			{
    				if (arr[begin1] < arr[begin2])
    				{
    					tem[indextem] = arr[begin1];
    					++indextem;
    					++begin1;
    				}
    				else
    				{
    					tem[indextem] = arr[begin2];
    					++indextem;
    					++begin2;
    				}
    			}
    			//将子数组[i, i + gap)或子数组[i + gap, i + 2 * gap)中未完成归并的元素完成归并
    			while (begin1 < end1)
    			{
    				tem[indextem] = arr[begin1];
    				++indextem;
    				++begin1;
    			}
    			while (begin2 < end2)
    			{
    				tem[indextem] = arr[begin2];
    				++indextem;
    				++begin2;
    			}
    
    			//将完成归并的一组序列从tem数组中拷贝回arr数组中对应下标处
    			for (int j = i; j < end2; ++j)
    			{
    				arr[j] = tem[j];
    			}
    		}
    	}
    
        free(tem);
    }
  • 两个子数组的归并操作见前面的章节; 

  • 初步非递归归并排序函数只能处理元素个数为2^{n}(即数组刚好能被完全二分n次)的数组

  • 想要使排序函数能够处理任意元素个数的数组,我们就必须进行算法边界条件分析边界修正

一般情况下(所排序数组元素个数不为2^{n})边界条件分析:

  • 待排序数组的元素个数为size
  • 函数中只有下标end1,begin2,end2存在越界的可能(函数中begin1和end1,begin2和end2分别用于维护两个在数组arr中待归并的相邻子数组)
  • 所处理的数组元素个数不为2^{n}时,可能会出现下图中两种下标越界情况

  1. end1(end1==begin2)越界(end1>size)(此时end2一定也越界)此时可以直接break终止i控制的循环(end1>size说明arr数组按照gap划分后尾部待归并区间数量只有一个,无须进行归并操作)
  2. end2越界(end2>size)(end1没越界即(end1<size))

    此时要将end2修正为size,后续便可以完成arr数组(按照gap划分后)尾部剩余的两个子数组的归并操作:

经过边界修正后的非递归归并排序函数

void MergeSortNonR(int* arr, int size)
{
	assert(arr);
	int* tem = (int*)malloc(sizeof(int) * size); //tem数组用于完成归并操作
	assert(tem);

	

	for (int gap = 1; gap < size; gap *= 2)      //完成logN个层次的子数组的归并
	{
		int indextem = 0;						 //用于将数据归并到tem数组中的下标变量
		for (int i = 0; i < size; i += 2 * gap)  //i每次跳过一个归并序列组
		{
			//对子数组[i,i+gap)和子数组[i+gap,i+2*gap)进行归并操作
			int begin1 = i;                      //begin1和end1维护一个子数组
			int end1 = i + gap; 
			int begin2 = i + gap;				 //begin2和end2维护一个子数组
			int end2 = i + 2 * gap;

			//进行边界修正防止越界,并且保证归并排序能完整进行
			if (end1 > size)
			{
				break;                           //arr数组按照gap划分后尾部待归并区间数量只有一个,无须进行归并操作
			}
			if (end2 > size)
			{
				end2 = size;                     //修正end2边界,以完成arr数组尾部剩余的两个子数组的归并操作
			}
			
			while (begin1 < end1 && begin2 < end2)
			{
				if (arr[begin1] < arr[begin2])
				{
					tem[indextem] = arr[begin1];
					++indextem;
					++begin1;
				}
				else
				{
					tem[indextem] = arr[begin2];
					++indextem;
					++begin2;
				}
			}
			//将子数组[i, i + gap)或子数组[i + gap, i + 2 * gap)中未完成归并的元素完成归并
			while (begin1 < end1)
			{
				tem[indextem] = arr[begin1];
				++indextem;
				++begin1;
			}
			while (begin2 < end2)
			{
				tem[indextem] = arr[begin2];
				++indextem;
				++begin2;
			}

			//将完成归并的一组序列从tem数组中拷贝回arr数组中对应下标处
			for (int j = i; j < end2; ++j)
			{
				arr[j] = tem[j];
			}
		}
	}
	free(tem);
}

排序实测:

int main()
{
    //排序100万个数据
    srand(time(0));
	const int N = 1000000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
	}

	int begin = clock();
	MergeSortNonR(a1,N);
	int end = clock();
	printf("MergeSortNonR:%d\n", end - begin);
	JudgeSort(a1, N); //判断序列是否有序的函数
	free(a1);
}

  • 非递归归并排序递归归并排序算法思想上没有任何区别(只是子数组归并的顺序不同而已) 两者的时间复杂度都是O(NlogN),空间复杂度都是O(N)(算法中需要开辟额外的数组tem来完成子序列两两归并操作),但是递归归并排序有额外的系统栈开销.

  • 139
    点赞
  • 244
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 124
    评论
归并排序是一种经典的排序算法,它采用分治的思想,将一个大问题分解成若干个小问题,然后合并小问题的解来得到大问题的解。归并排序递归实现非常简单,但实际上我们也可以使用非递归的方式来实现归并排序非递归归并排序算法可以使用迭代的方式来实现。具体的实现思路是,先将原数组分成若干个长度为1的子数组,然后将相邻的子数组合并成长度为2的子数组,再将相邻的长度为2的子数组合并成长度为4的子数组,以此类推,直到将整个数组排好序为止。 下面是归并排序非递归算法的代码实现: ```python def merge_sort(arr): n = len(arr) step = 1 while step < n: for i in range(0, n, step * 2): left = i right = min(i + step, n) end = min(i + step * 2, n) merge(arr, left, right, end) step *= 2 return arr def merge(arr, left, right, end): left_arr = arr[left:right] right_arr = arr[right:end] k = left i = j = 0 while i < len(left_arr) and j < len(right_arr): if left_arr[i] <= right_arr[j]: arr[k] = left_arr[i] i += 1 else: arr[k] = right_arr[j] j += 1 k += 1 while i < len(left_arr): arr[k] = left_arr[i] i += 1 k += 1 while j < len(right_arr): arr[k] = right_arr[j] j += 1 k += 1 ``` 在上面的代码中,`merge_sort` 函数使用一个变量 `step` 来表示当前合并的子数组的长度,初始值为1。然后在一个 `while` 循环中,每次将相邻的两个长度为 `step` 的子数组合并成一个长度为 `step*2` 的子数组,直到 `step` 大于等于数组长度为止。在合并子数组的时候,我们使用 `merge` 函数将两个子数组合并成一个有序的子数组。 需要注意的是,在 `merge` 函数中,我们使用了一个 `left` 变量来表示左子数组的起始位置,使用一个 `right` 变量来表示右子数组的起始位置,使用一个 `end` 变量来表示右子数组的结束位置。这是因为在合并子数组的时候,右子数组的起始位置并不是固定的,而是根据 `left` 和 `step` 来计算的。 归并排序非递归实现虽然比递归实现稍微复杂一些,但它具有更好的空间复杂度和更好的稳定性,是一种非常实用的排序算法

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 124
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力的青菜

谢谢各位爹娘的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值