merge_sort

上次一个题让写一种稳定的排序算法,就是归并排序咯,然而不会,谨以此记住

归并排序:

时间复杂度 n*log(2) n , 状态 稳定  辅助空间 O(n)

典型的一种二分策略的排序,整个过程分为两步

1. 二分,把待排序数组分成两部分,再二分,直到只剩一个元素为止;

2.合并,每次把两个数组按照从小到大的顺序合并,每一次合并的过程就会有一部分元素变成有序的,

3.分治策略很重要

一个不算精简的代码:

void merge(int* src, int* des, int low,int mid, int high) //合并
{
	int i=low;
	int j=mid+1;
	int k=low;
	while((i<=mid)&&(j<=high))
	{
		if(src[i]<src[j])
		{
			des[k++] = src[i++];
		}
		else
		{
			des[k++] = src[j++];
		}
	}
	while(i<=mid)
	{
		des[k++] = src[i++];
	}
	while(j<=high)
	{
		des[k++] = src[j++];
	}
	
}


void  devide(int* src, int* des, int low, int high, int max)  //二分
{
	if(low == high) //只剩一个元素,递归划分结束,开始合并
	{
		des[low] = src[low];
	}
	else
	{	//递归的进行两路划分
		int mid = (low + high) / 2;
		int* tmp = (int *)malloc(sizeof(int)* max);
		if(tmp != NULL)
		{
			devide(src, tmp, low, mid, max);
			devide(src, tmp, mid+1, high, max);
			
			merge(tmp, des, low, mid, high);
		}
		free(tmp);
	}
	
} 

void merge_sort(int* src, int length)
{
	devide(src, src, 0, length-1, length);
}

顺便改成模板函数

template <typename T>
void merge(T* src, T * des, int low, int mid, int high) //归并
{
	int i = low;
	int j = mid + 1;
	int k = low;

	while ((i <= mid) && (j <= high)) //将小的放到目的数组中
	{
		if (src[i] < src[j]) //那个临时数组
		{
			des[k++] = src[i++];
		}
		else
		{
			des[k++] = src[j++];
		}
	}

	while (i <= mid)  //若还剩几个尾部元素
	{
		des[k++] = src[i++];
	}
	while (j <= high) //若还剩几个尾部元素
	{
		des[k++] = src[j++];
	}
}
//每次分为两路 当只剩下一个元素时,就不需要在划分
template <typename T>
void devide(T *src, T* des, int low, int high, int max) //划分
{
	if (low == high) //只剩一个元素时,直接赋值给des
	{
		des[low] = src[low];
	}
	else
	{
		int mid = (low + high) / 2;
		T* tmp = (T*)malloc(sizeof(T)*max);

		//递归进行两路,两路的划分 
		//当剩下一个元素的时,递归划分结束,然后开始merge归并操作
		if (tmp != NULL)
		{
			devide(src, tmp, low, mid, max);
			devide(src, tmp, mid + 1, high, max);
			merge(tmp, des, low, mid, high);  //调用归并函数进行归并
		}

		free(tmp);
	}
}

template <typename T>
void mergesort(T* src, int len)
{
	devide(src, src, 0, len - 1, len);
}


然而发现并没有什么卵 用, 因为归并所用到的辅助空间太大,对于对象之间的排序,光是进行内存分配,和对象拷贝,都不划算,

也可以改成对指针进行存储,然后交换指针,,,,未完

merge_sort()是一种常用的排序算法,它采用分治法的思想,将一个大问题分解为多个小问题来解决。具体步骤如下: 1. 分解:将待排序的数组不断地二分,直到每个子数组只有一个元素。 2. 合并:将相邻的两个子数组按照顺序合并,形成一个有序的子数组。 3. 重复合并:不断地重复合并相邻的子数组,直到最终得到一个完全有序的数组。 下面是C++中merge_sort()函数的一个示例实现: ```cpp // 合并两个有序数组 void merge(int arr[], int left, int mid, int right) { int n1 = mid - left + 1; int n2 = right - mid; // 创建临时数组 int L[n1], R[n2]; // 将数据复制到临时数组 for (int i = 0; i < n1; i++) { L[i] = arr[left + i]; } for (int j = 0; j < n2; j++) { R[j] = arr[mid + 1 + j]; } // 合并临时数组 int i = 0, j = 0, k = left; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i]; i++; } else { arr[k] = R[j]; j++; } k++; } // 复制剩余元素 while (i < n1) { arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j]; j++; k++; } } // 归并排序 void merge_sort(int arr[], int left, int right) { if (left < right) { int mid = left + (right - left) / 2; // 分解为子问题 merge_sort(arr, left, mid); merge_sort(arr, mid + 1, right); // 合并子问题的解 merge(arr, left, mid, right); } } ``` 这是一个递归实现的merge_sort()函数,它通过不断地将数组分解为更小的子数组,并将它们合并成有序数组来完成排序。你可以调用merge_sort()函数来对一个整数数组进行排序。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值