归并排序(递归+非递归)

Posted 2022-12-13

(文章目录)

1. 归并排序 递归

1.基本思想

2. 使用两个函数完成归并

3. 递归结束条件

4.时间复杂度与空间复杂度计算

1. 时间复杂度

2. 空间复杂度

5. 代码

void mergesort1(int* a, int left, int right,int* tmp)

if (left >= right)//递归 结束条件

return;

int mid = (left + right) / 2;
// [left ,mid] [mid+1 ,right] 
mergesort1(a, left, mid,tmp);
mergesort1(a, mid + 1, right,tmp);
// 合并两个有序数组，并将其赋给临时数组tmp，最后拷贝原数组中(合并一部分，拷贝一部分)
int begin1 = left;
int end1 = mid;
int begin2 = mid + 1;
int end2 = right;
int i = left;//由于部分合并，所以i从left开始
while (begin1<=end1&&begin2<=end2)

if (a[begin1] < a[begin2])

tmp[i++] = a[begin1++];

else

tmp[i++] = a[begin2++];


 //若出了循环后，也有可能在两个数组有剩余的情况
while (begin1 <= end1)//若 [begin1,end1]数组有剩余，直接赋值到tmp数组

tmp[i++] = a[begin1++];

while (begin2 <= end2)//若 [begin2,end2]数组有剩余，直接赋值到tmp数组

tmp[i++] = a[begin2++];

 //第一种拷贝方式
memcpy(a+left, tmp+left, sizeof(int) * (right - left + 1));
 //第二种拷贝方式
/*for (i = 0; i <= right; i++)

a[i] = tmp[i];
*/

void mergesort(int* a, int n)// 归并排序 递归

int* tmp = (int*)malloc(sizeof(int) * n);
mergesort1(a, 0, n - 1,tmp);
free(tmp);
tmp = NULL;

2. 归并排序 非递归

1. 思想

2. 越界问题

1. .end1 beign2 end2 越界

方式 1

方式 2

整体拷贝与拷贝一部分，归并一部分的区别

2. begin2 end2 越界

方式 1

方式 2

3. end2 越界

3. 代码

void mergesortNonR(int* a, int n)//归并排序 非递归

	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	
		perror("malloc fail");
		exit(-1);
	
	int gap = 1;
	int i = 0;
	int j = 0;
	while (gap < n)
	
		for (i = 0; i < n; i += 2*gap)
		
			//[ i , i+gap-1][i+gap,i+2*gap-1]
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2*gap-1 ;
			j = i;

			//1. end1 begin2 end2 越界
			if (end1 >= n)//end2是下标的存在 ，最多取到 n-1
			
				break;
			
			//if (end1 >= n)//修正区间
			//
			//	end1 = n - 1;
			//	begin2 = n;
			//	end2 = n - 1;
			//
			//2.  begin2 end2 越界
			else if (begin2 >= n)
			
				break;
			
			/*else if (begin2 >= n)
			
				begin2 = n;
				end2 = n - 1;
			*/
			//3. end2 越界
			else if (end2 >= n)
			
				end2 = n - 1;
			
			while (begin1 <= end1 && begin2 <= end2)
			
				if (a[begin1] <= a[begin2])
				
					tmp[j++] = a[begin1++];
				
				else
				
					tmp[j++] = a[begin2++];
				
			
			while (begin1 <= end1)
			
				tmp[j++] = a[begin1++];
			
			while (begin2 <= end2)
			
				tmp[j++] = a[begin2++];
			
			//归并一部分，拷贝一部分
			memcpy(a+i, tmp+i, sizeof(int) * (end2-i+1));
		
		gap *= 2;
	
	free(tmp);
	tmp = NULL;