七大排序算法之改进算法系列(六)——归并排序

归并排序(Merging Sort):

归并排序是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。实际上就是将数据序列划分为越来越小的半子表,再对半子表排序,最后再用递归方法将排好序的半子表合并成越来越大的有序序列。

图解如下:

 

归并排序的递归实现代码:

#include <iostream>
#define MAXSIZE 10

using namespace std;

// 实现归并,并把最后的结果存放到list1里
void merging(int *list1, int list1_size, int *list2, int list2_size)
{
	int i, j, k, m;
	int temp[MAXSIZE];

	i = j = k = 0;

	while (i < list1_size && j < list2_size)
	{
		if (list1[i] < list2[j])
		{
			temp[k++] = list1[i++];
		}
		else
		{
			temp[k++] = list2[j++];
		}
	}

	while (i < list1_size)
	{
		temp[k++] = list1[i++];
	}

	while (j < list2_size)
	{
		temp[k++] = list2[j++];
	}

	for (m = 0; m < (list1_size + list2_size); m++)
	{
		list1[m] = temp[m];
	}
}

void MergeSort(int k[], int n)
{
	if (n > 1)
	{
		int *list1 = k;
		int list1_size = n / 2;
		int *list2 = k + n / 2;
		int list2_size = n - list1_size;

		MergeSort(list1, list1_size);
		MergeSort(list2, list2_size);

		merging(list1, list1_size, list2, list2_size);
	}
}

int main()
{
	int i, a[10] = { 5, 2, 6, 0, 3, 9, 1, 7, 4, 8 };

	cout << "排序前的数组是:";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	MergeSort(a, 10);

	cout << "排序后的数组是:";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	return 0;
}

代码结果:


 归并排序的非递归方法:

递归方法是先拆分成一个个小的子表再递归回一个完整的表的过程。

而迭代方法不需要这样,直截了当,把表两个两个排序再四个四个再八个八个......

看代码:

#include <iostream>
#include <malloc.h>
#define MAXSIZE 10

using namespace std;

void MergeSort(int k[],int n)
{
	int i,next,left_min,left_max,right_min,right_max;
	//开辟一个与原来数组一样大小的空间用来存储用
	int *temp = (int *)malloc(n * sizeof(int));
	//逐级上升,第一次比较2个,第二次比较4个,第三次比较8个。。。
	for(i=1; i<n; i*=2)
	{
		//每次都从0开始,数组的头元素开始
		for(left_min=0; left_min<n-i; left_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;
			//右边的下标最大值只能为n
			if(right_max>n)
			{
				right_max = n;
			}
			//next是用来标志temp数组下标的,由于每次数据都有返回到K,
			//故每次开始得重新置零
			next = 0;
			//如果左边的数据还没达到分割线且右边的数组没到达分割线,开始循环
			while(left_min<left_max&&right_min<right_max)
			{
				if(k[left_min] < k[right_min])
				{
					temp[next++] = k[left_min++];
					
				}
				else
				{
					temp[next++] = k[right_min++];
				}
			}
			//上面循环结束的条件有两个,如果是左边的游标尚未到达,那么需要把
			//数组接回去,可能会有疑问,那如果右边的没到达呢,其实模拟一下就可以
			//知道,如果右边没到达,那么说明右边的数据比较大,这时也就不用移动位置了
			
			while(left_min < left_max)
			{
				//如果left_min小于left_max,说明现在左边的数据比较大
				//直接把它们接到数组的min之前就行
				k[--right_min] = k[--left_max];	
			}
			while(next>0)
			{
				//把排好序的那部分数组返回该k
				k[--right_min] = temp[--next];		
			}
		}
	}
}

int main()
{
	int i, a[10] = { 5, 2, 6, 0, 3, 9, 1, 7, 4, 8 };

	cout << "排序前的数组是:";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	MergeSort(a, 10);

	cout << "排序后的数组是:";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	return 0;
}

 结果:

归并排序的时间复杂度和空间复杂度分析:

递归版本:

时间复杂度:O(nlogn)

空间复杂度:O(n+logn)

迭代版本:

时间复杂度:O(nlogn)

空间复杂度:O(n)

 

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值