数据结构--向量--归并排序

       好了，我们现在来看一下归并排序。

本页内容

    1.归并排序原理

    2.代码实现

    3.在向量模板中实现

    4.总体评价

1.归并排序的原理

      归并排序利用分而治之的策略，将数组从中分割成两个小数组，两个小数组再以相同的方式分割，一直这样递归分割，直至数值元素个数为1，无法再分为止。让后再合并有序子序列(1个元素的序列也是有序序列，合并后的序列也要为有序的)，最终会得到一个有序的数列，即我们所要的数列。可向下面这样解释：

      

2.代码实现：

#include<iostream>
using namespace std;
void merge(int *A,int lo,int mi,int hi)//二路归并 
{
	int lb=mi-lo;
	int lc=hi-mi;
	int *B=new int [lb];//为前段分配存储空间
	for(int i=0;i<lb;i++)//将前段移入存储空间
	{
		B[i]=A[i+lo];
	}
	int*C=new int[lc];//后半段
	C=A+mi;//直接使用原数组A的后半段
	int j=0;//用于记录B中进行了比较的元素个数 
	int k=0;//用于记录C中进行了比较的元素个数
	int i=0;//用于计数 
	while(j<lb||k<lc)//但B或C中元素还没插入完成时继续
	{
	     if(j<lb&&(k>=lc||B[j]<=C[k]))//当B还有元素,C无时插入B中的元素到A,或者B还有元素，C也有但是B中元素小于等于C中时插入B的元素到A
		 {
		 	A[i+lo]=B[j];
		 	++i;
		 	++j;
		 }
		 if(k<lc&&(j>=lb||C[k]<B[j])) //原因同上
		 {
		 	A[i+lo]=C[k];
			 ++i;
			 ++k; 
		 }
		  
	} 
	delete [] B;//释放B的空间 
}
void mergeSort(int *A,int lo,int hi)
{
	if(hi-lo<2)//单元区间只有一个元素，有序 
	{
		return ;
	}
	int mi=(lo+hi)/2;//以中点为界
	mergeSort(A,lo,mi);//对前半段排序
	mergeSort(A,mi,hi);//对后半段排序
	merge(A,lo,mi,hi);//归并 
}
int main()
{
	/************归并排序*********/
	int a[10];
	cout<<"测试数组："; 
	for(int i=0;i<10;i++)
	{
		a[i]=9-i;
		cout<<a[i]<<" ";
	}
	cout<<endl;
	cout<<"mergeSort后：";
	mergeSort(a,0,10);
	for(int i=0;i<10;i++)
	{
		cout<<a[i]<<" ";
	} 
	/*****************************/
	cout<<endl; 
	return 0;
} 

     运行结果：

     

     大家要注意这里：

     

      首先k>lc与B[j]<=C[k]的位置不能调换，因为"||"语句是先判断前面是否正确，如果正确则不会在执行后面的语句，直接返回true。如果k已经满足k>=lc，则C[k]已经越界，但是由于B[j]<=C[k]在k>=lc后面，所以不会执行，程序还是安全的。但如果将它放在前面，则有能在k>=lc的情况下执行，造成数组越界，程序是不安全的。还有要注意B[j]<=C[k]的“=”号是不能省的。如果省掉，则当B[j]==C[k]时，程序将进入死循环。

       我们在来看一下merge函数是怎么运行的。merge的作用是将两个有序的数列合并成一个有序的数列。我们采用的是二路归并的算法，其原理如下图：

        

       每次都是从两个有序数列中取出最小的那个值，放在新的数列的后面。直到全部放完为止。这样新的数列就是有序的了。

3.在向量模板中实现

template<typename T>
void myVector<T>::merge(Rank lo,Rank mi,Rank hi)
{
	int lb=mi-lo;
	int lc=hi-mi;
	T*A=_elem+lo;
	T*B=new int[lb];
	T*C=_elem+mi;
	for(int i=0;i<lb;B[i]=A[i++]);//复制前半段 
	for(int i=0,j=0,k=0;j<lb||k<lc;)//B[j]与C[k]中小者转置A末尾 
	{
		if(j<lb&&(lc<=k||B[j]<=C[k])) A[i++]=B[j++];//C[k]已无或不小 
		if(k<lc&&(lb<=j||C[k]<B[j])) A[i++]=C[k++];//B[j]已无或更大 
	}
	delete [] B;//释放空间 
	
} 
template<typename T>
void myVector<T>::mergeSort(Rank lo,Rank hi)
{
	if(hi-lo<2)//单元素区间有序 
	{
		return;
	}
	Rank mi=(lo+hi)/2;//以中点为界 
	mergeSort(lo,mi);//对前半段排序 
	mergeSort(mi,hi);//对后半段排序 
	merge(lo,mi,hi);//归并 
}

4.总体评价  

    归并算法的复杂度为O(nlogn)，这是很不错的了。它的稳定性较好，且可扩展性极佳，就是用的空间多了点而已。

想要学习更多关于向量的知识，请点击！！