排序3——归并排序

涉及到递归,可以看我前面写的:https://blog.csdn.net/2302_79366101/article/details/134188951icon-default.png?t=N7T8https://blog.csdn.net/2302_79366101/article/details/134188951

如图所示,这就是归并排序的大致流程。我们分为:分解与归并。既然已经有了思路,我们思考一下代码如何实现。首先,这是以一种分治的思想。我们要把求顺序的大问题分解为小问题。

在此我们再使用文字描述一下这个过程:

将子数组分到其中只有一个元素,此时我们就可以认为这个子数组是有序的,然后在得到左右两个这样只有一个元素的子数组后进入归并merge,得到一个更大的有序数组如圈1时的数组,其他子数组和这个过程相同,直至将所有其全部归并我们就会得到一个有序数组。

根据上面汉诺塔的经验,我们得出同样的思路,既然我们想要实现

我们只需要一个分,和一个治即可

分的思路已经给出,

治:

便是:已经有两个各自排好序的数组,我们从他们第一个数据开始比较,如果左第一个比右第一个小,那么我们直接给temp数组的第一个元素赋值左边第一个数,然后做比左边数组移动到下一位,如果等于或者大于右边的话,则把右边的赋值给temp,最后temp移动一位。

于是我们有代码:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void merge(int* src, int* dst, int begin, int mid, int end)
{
	int begin1 = begin;
	int begin2 = mid;
	int index = begin;
	while (begin1 < mid && begin2 < end) {
		if (src[begin1] < src[begin2]) {
			dst[index++] = src[begin1++];//[index++]由于运算的优先级,它用于自增一个变量的值,并返回自增前的值。
		}
		else {
			dst[index++] = src[begin2++];
		}
	}
	while (begin1 < mid) {
		dst[index++] = src[begin1++];
	}
	while (begin2 < end) {
		dst[index++] = src[begin2++];
	}
	memcpy(src + begin, dst + begin, (end - begin) * sizeof(int));
}
void _merge_sort(int* arr, int* tmp, int left, int right)
{
	if (left + 1 >= right) {
		return;
	}
	int mid = left + (right - left) / 2;
	_merge_sort(arr, tmp, left, mid);
	_merge_sort(arr, tmp, mid, right);
	merge(arr, tmp, left, mid, right);
}
void merge_sort(int* arr, int size)
{
	int* tmp = (int*)malloc(size * sizeof(int));
	_merge_sort(arr, tmp, 0, size);
	free(tmp);
}
int main()
{
	int arr[] = { 3,6,1,9,4,2,0,5,8,7 };
	int len = sizeof(arr) / sizeof(arr[0]);
	merge_sort(arr, len);
	int i = 0;
	for (i = 0; i < len; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}






上述代码过于复杂,可以进行简化:

思路同上:

#include <iostream>
using namespace std;
const int N=1e5 + 10;
int q[N], tmp[N];
//m输入的是n-1
void merge_sort(int q[], int l, int m)
{
	if (l >= m)  return;
	int mid = (l + m) >> 1;

	merge_sort(q, l, mid);
	merge_sort(q, mid + 1, m);

	int i = l, j = mid+1;
	int k = 0;
	while (i <= mid && j <= m)
	{
		if (q[i] <= q[j]) tmp[k++] = q[i++];
		else tmp[k++] = q[j++];
	}
	while (i <= mid) tmp[k++] = q[i++];
	while (j <= m) tmp[k++] = q[j++];

	for (i = l, j = 0; i <= m; i++, j++) q[i] = tmp[j];//数组转移
}

int main()
{
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> q[i];
	}

	merge_sort(q, 0, n - 1);

	for (int i = 0; i < n; i++)
	{
		cout << q[i];
	}
}

它整体的过程如下:


END  ps:我只是个初学者,全靠自学,所以知识上面肯定有很多漏洞,所以请多海涵! 感谢批评指正!

MPI(Message Passing Interface)是一种用于并行计算的编程模型和库。归并排序是一种经典的排序算法,适合并行计算。 在MPI中,可以通过发送和接收消息来实现进程间的通信。下面是一个基于MPI的归并排序的伪代码: ```python def parallel_merge_sort(data): # 获取进程总数和当前进程编号 size = MPI.COMM_WORLD.Get_size() rank = MPI.COMM_WORLD.Get_rank() # 计算每个进程要处理的数据量 chunk_size = len(data) // size remainder = len(data) % size # 将数据分发到各个进程 if rank == 0: for i in range(size): if i < remainder: chunk = data[i * (chunk_size + 1):(i + 1) * (chunk_size + 1)] else: chunk = data[remainder + i * chunk_size:remainder + (i + 1) * chunk_size] MPI.COMM_WORLD.send(chunk, dest=i, tag=0) # 接收数据 chunk = MPI.COMM_WORLD.recv(source=0, tag=0) # 对本地数据进行排序 chunk.sort() # 归并排序 for step in range(size): # 计算要交换数据的进程编号 partner = (rank + step) % size # 发送和接收数据 sendbuf = chunk recvbuf = MPI.COMM_WORLD.recv(source=partner, tag=step) if rank < partner: sendtag = step recvtag = step + size else: sendtag = step + size recvtag = step MPI.COMM_WORLD.send(sendbuf, dest=partner, tag=sendtag) chunk = merge(chunk, recvbuf) # 将排序好的数据返回 if rank == 0: result = [] for i in range(size): chunk = MPI.COMM_WORLD.recv(source=i, tag=size) result.extend(chunk) return result else: MPI.COMM_WORLD.send(chunk, dest=0, tag=size) ``` 在这个算法中,首先将原始数据分发到各个进程,然后每个进程对本地数据进行排序,接着对每个步骤进行归并排序,并且使用MPI的send和recv函数进行交换数据。最后将排序好的数据返回到主进程。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值