归并排序(Merge Sort)

最新推荐文章于 2024-09-15 10:42:58 发布
最新推荐文章于 2024-09-15 10:42:58 发布
阅读量874 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Algorithm 文章标签： merge 算法 delete system c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sysu_arui/article/details/7989046
本文详细介绍归并排序算法，包括递归和迭代两种实现方式，并提供完整的C++代码示例及测试用例。分析了归并排序的时间和空间复杂度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

归并排序维基百科：http://zh.wikipedia.org/wiki/归并排序

归并排序（Merge Sort，又称合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

1、递归算法

算法思想：

把待排序序列分成两段，然后对两段各自进行归并排序，最后把这两段的排序结果组合在一起。

(1)递归实现1

#include <cstdlib>
#include <iostream>

using namespace std;
 
/* 
  递归算法  
  对a[left,right]进行归并排序  
*/  
template<class T>  
void mergeSort(T* a, int left, int right)  
{  
    if(left < right)  
    {  
        int mid = (left + right)/2; //devide   
        mergeSort(a,left,mid);      //conquer  
        mergeSort(a,mid+1,right);   //conquer  
        merge(a,left,mid,right);    //combine  
    }  
}  
  
/* 
将有序段a[left,mid]和a[mid+1,right]合并为升序  
*/  
template<class T>  
void merge(T* a, int left, int mid, int right)  
{  
    int len1 = mid - left + 1;  
    int len2 = right - mid;  
      
    T* b = new T[len1];  
    T* c = new T[len2];  
    //copy  
    for(int i=0; i<len1; i++)  
    {  
        b[i] = a[left + i];  
    }  
    for(int j=0; j<len2; j++)  
    {  
        c[j] = a[mid + j + 1];  
    }  
    int i = 0;  
    int j = 0;  
    int k = left;  
    while(i < len1 && j < len2)  
    {  
        if(b[i] <= c[j])  
        {  
            a[k++] = b[i++];  
        }  
        else  
        {  
            a[k++] = c[j++];  
        }  
    }  
    while(i < len1)  
    {  
        a[k++] = b[i++];  
    }  
    while(j < len2)  
    {  
        a[k++] = c[j++];  
    }  
    delete[] b;  
    delete[] c;  
}  

int main(int argc, char *argv[])
{
	int n;  
    int* a = NULL;  
      
    while(cin>>n && n>0)  
    {
		a = new int[n];
        for(int i=0; i<n; i++)  
        {  
            cin>>a[i];  
        }
        mergeSort(a,0,n-1);  
        for(int i=0; i<n; i++)  
        {  
            cout<<a[i]<<" ";  
        }
        cout<<endl<<endl;
        delete [] a;
    }  
	
    system("PAUSE");
    return EXIT_SUCCESS;
}

该递归算法实现中，merge()函数里面空间复杂度为O(n)，虽然单次递归调用所需的最大辅助空间为O(n)，但是有lgn层递归调用。所以该算法的空间复杂度为O(nlgn)。下面给出的第2种递归实现，做了一点改善，算法空间复杂度为O(n)。

(2)递归实现2

#include <cstdlib>
#include <cstdio>
#include <iostream>

using namespace std;

/* 
  递归算法  
  对a[left,right]进行归并排序  
*/  
template<class T>  
void mergeSort(T* a, T* b, int low, int high)  
{  
    if(low < high)  
    {  
        int mid = (low + high)/2;		//devide   
        mergeSort(a, b, low, mid);		//conquer  
        mergeSort(a, b, mid+1, high);	//conquer  
        merge(a, b, low, mid, high);  	//combine  
    }
}  

/* 
将有序段a[low,mid]和a[mid+1,high]合并为升序
b[]为辅助数组 
*/  
template<class T>
void merge(T* a, T* b, int low, int mid, int high)
{
	memcpy(b + low, a + low, (high - low + 1)*sizeof(T));
	int i,j,k;
	
	for(i=low, j=mid+1, k=low; i <= mid && j <= high; k++)
	{
		if(b[i] <= b[j])
		{
			a[k] = b[i++];
		}
		else
		{
			a[k] = b[j++];
		}
	}
	while(i <= mid)
	{
		a[k++] = b[i++];
	}
	while(j <= high)
	{
		a[k++] = b[j++];
	}
}

int main(int argc, char *argv[])
{
	int n;  
    int* a = NULL;
    int* b = NULL;
      
    while(cin>>n && n>0)  
    {
		a = new int[n];
		b = new int[n];//辅助空间 
        for(int i=0; i<n; i++)  
        {  
            cin>>a[i];  
        }
        mergeSort(a, b, 0, n-1);  
        for(int i=0; i<n; i++)  
        {  
            cout<<a[i]<<" ";  
        }
        cout<<endl<<endl;
        delete [] a;
        delete [] b;
    }  
	
    system("PAUSE");
    return EXIT_SUCCESS;
}
2、迭代算法

根据递归算法，我们很容易把代码改为非递归，只需根据归并段的大小逐段进行归并，实现如下。

#include <cstdlib>
#include <iostream>

using namespace std;

/*将有序段a[low,mid]和a[mid+1,high]合并为升序
 *存入数组b 
*/
template<class T>
void merge(T* a, T* b, int low, int mid, int high)
{
	int beg1 = low;
	int end1 = mid;
	int beg2 = mid + 1;
	int end2 = high;
	int k = low;
	
	while(beg1 <= end1 && beg2 <= end2)
	{
		if(a[beg1] <= a[beg2])
		{
			b[k++] = a[beg1++];
		}
		else
		{
			b[k++] = a[beg2++];
		}
	}
	if(beg1 <= end1)
	{
		for(int i=beg1; i<=end1; i++)
		{
			b[k++] = a[i];
		}
	}
	else
	{
		for(int i=beg2; i<=end2; i++)
		{
			b[k++] = a[i];
		}
	}
}

/*将数组a分段两两归并
 *a为数组首地址，size为数组大小 
 seg为段的大小 ，初始值为1 
 b[]为临时数组 
*/
template<class T>
void mergePass(T* a, T* b, int seg, int size)
{
	int seg_start = 0;
	while(seg_start <= size - 2*seg)//注意临界点 
	{
		merge(a, b, seg_start, seg_start + seg - 1, seg_start + 2*seg - 1);
		seg_start += 2*seg;		//下一个归并段的起始位置 
	}
	//剩余长度小于两个归并段长度，但大于一个归并段长度 
	if(seg_start + seg < size)
	{
		merge(a, b, seg_start, seg_start + seg - 1, size - 1);
	}
	else//剩余长度小于等于一个归并段长度
	{
		for(int i=seg_start; i<size; i++)
		{
			b[i] = a[i];
		}
	}
}

/*迭代算法 
 *将数组a归并排序
 *a为数组首地址，size为数组大小 
*/
template<class T>
void mergeSort(T* a, int size)
{
	int seg = 1;//归并段的初始长度为1 
	T* temp = new T[size];
	while(seg < size)
	{
		mergePass(a, temp, seg, size);
		seg += seg;//归并段增大1倍 
		mergePass(temp, a, seg, size);
		seg += seg;//归并段增大1倍 		
	}
	delete [] temp;
}

int main(int argc, char *argv[])
{
	int n;  
    int* a = NULL;  
      
    while(cin>>n && n>0)  
    {
		a = new int[n];
        for(int i=0; i<n; i++)  
        {  
            cin>>a[i];  
        }
		mergeSort(a,n);
        for(int i=0; i<n; i++)  
        {  
            cout<<a[i]<<" ";  
        }
        cout<<endl<<endl;
        delete [] a;
    }  
	
    system("PAUSE");
    return EXIT_SUCCESS;
}

3、测试用例

测试用例：(input中一行为一个test case，行首元素为该tese case 中所含元素)

input:
3 3 2 1
10 1 3 7 8 20 12 19 80 34 5
output:
1 2 3 
1 3 5 7 8 12 19 20 34 80

4、算法复杂度分析

(1)对于输入规模为n，归并两个子序列的函数merge()的复杂度为Θ(n)
(2)算法递归式为:T(n) = 2T(n/2)+cn (n>1)
(3)构造递归树，得递归树的深度为lgn
(4)递归树每一层的复杂度为cn,算法总的复杂度为cnlgn即Θ(nlgn)

参考资料：

[1]算法导论（第2版）

[2]王晓东 计算机算法设计与分析（第3版）

C/C++ 归并排序Merge Sort算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-23 1884
归并排序（Merge Sort）是一种分治算法，将待排序的序列分成若干个子序列，分别对每个子序列进行排序，然后再将已排序的子序列合并成整体有序的序列。
PHP实现归并排序Merge Sort算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-21 72
PHP实现归并排序Merge Sort算法(附完整源码)
mergesort
01-19
基于c++的归并排序算法。排序算法大体可分为两种： 　　　　一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 　　　　另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。
merge sort
xiajie1989的专栏
06-12 5290
归并排序 算法步骤：  先对子集排序，再归并。 首先归并是最简单的， 先写归并，把两个有序子集合并 void Merge(vector &src ,vector &des, int low, int mid ,int high) { int i = low; //左边的集合开始索引 int j = mid +1; //右边的集合开始索引 int k = low; //最后保存的集合索
MergeSort
hertioy的博客
08-13 202
#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <assert.h> #include <string.h> void MergeData(int* array,int left,int...
merge-sort
skywatercomputer的专栏
03-28 496
Divide and conquer is the core idea of merge sort. You can recursively divide the original array into two sub-arrays, until each sub-array only has one element. At the last, it looks like a tree, the ...
基于python的排序算法-归并排序Merge Sort
06-25
归并排序（Merge Sort）是一种高效的、稳定的排序算法，它采用了...在压缩包文件"基于python的排序算法-归并排序Merge Sort"中，可能包含的就是关于这个话题的详细讲解、代码示例或其他相关资料，可供深入学习和实践。
c++ 算法 归并排序 Merge Sort
JIAN_ZANG1125的博客
10-10 833
归并排序 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用，归并排序将两个已经有序的序列合并成一个有序的序列。 思路：假设我们有一个没有排好序的序列，那么我们首先使用分割的方法将这个序列分割成一个个已经排好序的子序列（当一个序列只有一个元素时，该序列自然是有序的）。然后再利用归并的方法将一个个有序的子序列合并成排好序的序列。 下面就一常用的二路归并排序讲解分割和合并的过程，看下图 ...
排序 - 归并排序(Merge Sort)
abclyq的博客
06-10 842
将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并
Merge Sort
a free man
01-27 636
递归
MergeSort(合并排序)
c++ 中的符号->
10-11 8962
mergeSort的关键是 merge。但是一个数组怎么来merge？所以，它是分两步走的，首先它要把所给的数组分割开来，然后对分割开来的子数组进行合并。之前我们讲过快排也要分割数组，但是这里的分割数组相对简单。重点是如何将分割开来的数组合并起来 先上图，看图比较容易理解： MergeSort过程分析 经过我们的演示可以发现，我们的合并是沿着当初分割的原路合并的，在合并的时候将元素的大...
merge sort(归并排序)
沉璧浮光
02-04 1199
转载自：http://java2novice.com/java-sorting-algorithms/merge-sort/ Merge sort is a divide and conquer algorithm. Steps to implement Merge Sort: 1) Divide the unsorted array into n partition
归并排序（Merge Sort）
Broken_x的博客
09-15 1221
归并排序（Merge Sort）是一种经典的排序算法，它采用分治法（Divide and Conquer）策略，将一个大数组分为两个小数组，分别进行排序，然后将这两个已排序的小数组合并成一个有序的大数组。归并排序在最坏情况下的时间复杂度为 O(nlog⁡n)O(nlogn)，并且是一种稳定的排序算法。归并排序是一种高效且稳定的排序算法，适用于大规模数据的排序。通过分治法的思想，归并排序能够在最坏情况下保持 O(nlog⁡n)O(nlogn) 的时间复杂度。
归并排序（Merge sort）
最新发布
03-18
### 归并排序的实现原理 归并排序是一种基于分治法（Divide and Conquer）的有效排序算法。其核心思想是通过将待排序数组分割为更小的部分，分别对这些部分进行排序后再将其合并成为一个整体有序的结果[^1]。 具体来说，归并排序的过程可以分为以下几个方面： #### 1. **分解** 整个数据集被递归地划分为较小的子集合，直到每个子集合仅包含单个元素为止。因为单一元素本身已经是有序的，所以这一步骤完成了基础单元的创建[^2]。 #### 2. **合并** 当所有的子集合都已经被拆解到最小单位之后，开始逐步地把它们两两合并起来，在每次合并的过程中都会确保新形成的组合也是按照顺序排列好的。这种“归并”的过程会一直持续下去，直至最终形成一个完整的、完全有序的数据列表[^3]。 以下是归并排序的核心伪代码表示： ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left_half = merge_sort(arr[:mid]) right_half = merge_sort(arr[mid:]) return merge(left_half, right_half) def merge(left, right): sorted_array = [] i = j = 0 while i < len(left) and j < len(right): if left[i] < right[j]: sorted_array.append(left[i]) i += 1 else: sorted_array.append(right[j]) j += 1 sorted_array.extend(left[i:]) sorted_array.extend(right[j:]) return sorted_array ``` 这段代码展示了如何使用 Python 来实现归并排序的功能。其中 `merge` 函数负责执行实际的合并操作，而 `merge_sort` 则控制着递归调用以及何时停止进一步划分输入数组。 ### 时间复杂度分析 由于每一次都将当前序列分成两半处理，并且每一层都需要遍历全部 n 项来进行比较和移动，因此总的运行时间为 O(n log n)。 ### 稳定性特点 值得注意的是，归并排序属于稳定性的排序方式之一，这意味着即使存在相等的关键字记录也不会改变彼此原有的次序关系。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值