归并排序(Merge Sort)

本文详细介绍归并排序算法,包括递归和迭代两种实现方式,并提供完整的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版)

### 归并排序的实现原理 归并排序是一种基于分治法(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、付费专栏及课程。

余额充值