架构人生

根据Merge Sort原理, 自己实现的归并排序算法+详细注释+代码(C#,C/C++) [分享]

本文是受前面的一篇《C#实现所有经典排序算法》飛雪飄寒 影响,应邀请,把我曾经实现的归并排序算法拿出来分享,欢迎改善:

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

1. 不多废话,我已经把注释写得很详细了,C#实现的分享如下:

        /// <summary>
        
/// 归并排序之归:归并排序入口 
        
/// Updated by Lihua at 05/06/2009
        
/// </summary>
        
/// <param name="data">无序数组</param>
        
/// <returns>有序数组</returns>
        
/// <author>lihua</author>
        
/// <copyright>www.zivsoft.com</copyright>
        int[] Sort(int[] data)
        {
            
//若data为null,或只剩下1 or 0个元素,返回,不排序
            if (null == data || data.Length <= 1)
            {
                
return data;
            }

            
//取数组中间下标
            
//int middle = data.Length / 2; //方法一:除2取整数
            int middle = data.Length >> 1;  //方法二:位移 (感谢读者hyper给出的这个效率稍高的方法)

            
//初始化临时数组let,right,并定义result作为最终有序数组,若数组元素奇数个,将把多余的那元素空间预留在right临时数组
            int[] left = new int[middle], right = new int[data.Length - middle], result = new int[data.Length];
            
            
//下面这句对性能有些影响,所以在上面有了改进,直接用data.Length-middle初始化right数组
            
//if (data.Length % 2 != 0) right = new int[middle + 1]; 

            
//int i = 0, j = 0;
            
//foreach (int x in data)//开始排序
            
//{
            
//    if (i < middle)//填充左数组
            
//    {
            
//        left[i] = x;
            
//        i++;
            
//    }
            
//    else//填充右数组
            
//    {
            
//        right[j] = x;
            
//        j++;
            
//    }
            
//}

            
//上面的foreach被改成了for循环
            
//for (int i = 0; i < data.Length; i++)
            
//{
            
//    if (i < middle)//用middle,不用left.Length
            
//    {
            
//        left[i] = data[i];
            
//    }
            
//    else
            
//    {
            
//        right[i - middle] = data[i]; //此处i-middle,让我省掉定义一个j,性能有所提高
            
//    }
            
//}
            
            
//经调查,用Array.Copy的确比上面的for循环优化很多
            Array.Copy(data, 0, left, 0, middle);//拷贝左数组
            Array.Copy(data, left.Length, right, 0, right.Length); //拷贝右数组

            left 
= Sort(left);//递归左数组
            right = Sort(right);//递归右数组
            result = Merge(left, right);//开始排序
            
//this.Write(result);//输出排序,测试用(lihua debug)
            return result;
        }
        
/// <summary>
        
/// 归并排序之并:排序在这一步
        
/// </summary>
        
/// <param name="a">左数组</param>
        
/// <param name="b">右数组</param>
        
/// <returns>合并左右数组排序后返回</returns>
        int[] Merge(int[] a, int[] b)
        {
            
//定义结果数组,用来存储最终结果
            int[] result = new int[a.Length + b.Length];
            
int i = 0, j = 0, k = 0;
            
while (i < a.Length && j < b.Length)
            {
                
if (a[i] < b[j])//左数组中元素小于右数组中元素
                {
                    result[k
++= a[i++];//将小的那个放到结果数组
                }
                
else//左数组中元素大于右数组中元素
                {
                    result[k
++= b[j++];//将小的那个放到结果数组
                }
            }
            
while (i < a.Length)//这里其实是还有左元素,但没有右元素
            {
                result[k
++= a[i++];
            }
            
while (j < b.Length)//右右元素,无左元素
            {
                result[k
++= b[j++];
            }
            
return result;//返回结果数组
        }

 

2. C/C++实现如下

//归并排序中之并
//Updated by zivsoft at 05/06/2009
int *Merge(int *a,int aLength,int *b,int bLength){
    
//合并结果指针
    int *result;
    
//初始化结果指针
    result=new int[aLength+bLength];

    
int i=0,j=0,k=0;

    
//定义左指针
    a=new int[aLength];
    
//定义右指针
    b=new int[bLength];

    
//元素排序,左右比较
    while(i<aLength&&j<bLength){
        
if(a[i]<b[j]){//左元素小于右元素
            result[k++]=a[i++];//将小的赋值到结果
        }
        
else{//左元素大于右元素
            result[k++]=b[j++];//将小的赋值到结果
        }
    }
    
while(i<aLength){//将最后一个元素赋值到结果
        result[k++]=a[i++];
    }
    
while(j<bLength){//将最后一个元素赋值到结果
        result[k++]=b[j++];
    }
    
return result;
}

//归并排序中之归拆分
//Updated by zivsoft at 05/06/2009
int *Split(int *data,int length){
    
int i=0,j=0,k=0;
    
int *left,*right,*result;
    
//取中间下标
    int middle=length/2;
    left
=new int[middle];
    right
=new int[middle];
    
//初始化有序结果数组
    result=new int[length];
    
//如果数组只有一个元素,直接返回,无需排序
    if(length<=1){
        
return data;
    }
    
int rightLength=0;

    
//奇数个元素的话,重新分配右数组长度
    if(length%2!=0){
        delete[] right;
        rightLength
=middle+1;
        right
=new int[rightLength];
    }
    
//拆分数组
    for(k=0;k<length;k++){
        
if(i<middle){
            left[i
++]=data[k];
        }
        
else{
            right[j
++]=data[k];
        }
    }
    left
=Split(left,i);//递归拆分左数组
    right=Split(right,rightLength);//递归拆分右数组
    result=Merge(left,i,right,rightLength);//排序并合并
    
//printarray(result,k); //输出,供lihua(zorywa)侧使用(zivsoft)
    return result;
}

 

感言:

这个算法是我在XX的一个面试题,问如何高效率将两个链表合并,并使之有序。很快想到归并排序(Merge Sort),想了想原理,把它实现了,不过现在又把它拿出来加了很多注释,应该没什么大问题了吧,重要是理解算法的精髓,用什么实现应该差不多,目前写了C#和C/C++两个版本,便于理解Merge Sort的原理,欢迎提建议,共同提高。 :-)

 

本文链接:http://www.cnblogs.com/architect/archive/2009/05/06/1450489.html
关于作者:http://www.zivsoft.com/

posted on 2009-05-06 10:59 周利华 阅读(...) 评论(...) 编辑 收藏

导航

公告