归并排序（递归和非递归）

归并排序是基于归并的思想实现的排序，是一种稳定排序算法，实现的Java代码如下：

 //归并排序
    public static void MergeSort(int[] arrays)
    {
         MSort(arrays,0,arrays.length-1);
        Print(arrays);
    }
    public static void MSort(int[] array,int low,int high)
    {
          int middle=(low+high)/2;
          if (low<high)
          {//递归实现，最终两两分组进行合并
              MSort(array,low,middle);
              MSort(array,middle+1,high);
              Merge(array,low,middle,high);
          }
    }
    //一个将数组的两部分归并
    public static void Merge(int[] arrays,int start,int begin,int high)
    {
        //对于数组的两部分进行合并
        int[] temp=new int[high-start+1];
        //需要控制两个的子数组的起始位置信息
        if (start<0||begin<0||high>arrays.length)
            return ;
        //开始对数组的两部分进行合并操作
        int i=start;
        int j,k;
        for (j=begin+1,k=0;i<=begin&&j<=high;k++)
            //其实此处K位置应该写k=start就可以避免之后的覆盖到新的数组中去
        {//比较大小，小的放在前面
            if (arrays[i]>arrays[j])
            {
                temp[k] = arrays[j++];
               // j++;
            }else
            {
                temp[k]=arrays[i++];
                //i++;
            }
        }
        //当子数组中个数不一致时，就将剩下的复制到新数组中去
        if (i<=begin)
        {
            for (int m = 0; m <=begin - i; m++)
                temp[k + m] = arrays[i + m];
        }
        if (j<=high)
        {
            for (int m=0;m<=high-j;m++)
            {
                temp[k+m] = arrays[j+m];
            }
        }
        //新的归并好的数组覆盖到原数组,其实可以直接在k的地方换一种写法
       for (int m=0;m<temp.length;m++)
           arrays[m+start]=temp[m];
    }
    //非递归的方法实现归并排序
    public static void MergeSort2(int[] arrays)
    {
        int k=1;
        while (k<arrays.length)
        {//不断归并有序序列
            MergrPass(arrays,k,arrays.length-1);
            k=2*k;
            MergrPass(arrays,k,arrays.length-1);
            k=2*k;
        }
        Print(arrays);
    }
    public static void MergrPass(int[] arrays,int s,int length)
    {
        int [] temp=new int[arrays.length];
        //将数组中相邻长度为S的子序列两两归并到数组中
        int i=0;
        while (i<=length-2*s+1)
        {
            Merge(arrays,i,i+s-1,i+2*s-1);
            i=i+2*s;
        }
        //最后又两种情况，一就是最后一组数据的最后一部分不足s个,二就是最后一组只有一组不到s个数组
        if (i<length-s+1)
            Merge(arrays,i,i+s-1,length);//最后一组数据的合并
        else
        {
            for (int j=i;j<=length;j++)//不足S个数
                temp[j]=arrays[j];
        }
    }

主要是要注意两个长度不一的数组实现归并切莫忘记在相同长度之后对于剩下的数组元素的进一步复制。