归并排序（非递归算法）

转自 http://blog.csdn.net/pigli/article/details/5755261

归并排序：

    将无序的序列划分成若干的子序列，然后将相邻的子序列归并到一个序列，这个归并过程一直继续下去，直到序列只有两个子序列，将这最后的两个子序列归并完成后，也即是排序完毕，得到的就是一个有序的序列。其中归并的过程也即是相邻两个子序列之间的排序问题。这是归并排序的基本原理。

    那么，思路也就是，在一趟排序中先将序列分成若干个子序列，然后再将相邻的子序列进行归并。将序列分成若干子序列，具体分法依赖于子序列的长度，确定了子序列的长度自然分成若干子序列也就不难了。长度L=2*趟数。将相邻子序列进行归并，实际上是进行将一个序列插入到另一个序列的操作。

    在这个过程中，需要借助一个与序列长度一致的数组空间，对暂排序列进行存储。

    这是一个非递归实现的思路。而二路归并算法也可以用递归实现它。下面是二路归并的非递归算法。

 

package Sort;
/*
 * 自底向顶二路归并：第一趟子序列的长度为1，第二趟子序列长度为1*2。。。。
 */
public class MergingSort
{
    private int[] array1 ;
    private int[] array2 ;
    private int length;

    public MergingSort(int[] array)
    {
        this.array1 = array;
        this.array2 = new int[array.length];
        this.length = array.length;
    }

    public void sort()
    {
        int sublength =1;
        int count =1;
        while(sublength<length)
        {
            int m =0;
            while((m+sublength)<=length)
            {
                if(m+2*sublength<length)
                {
                    if(count%2!=0)
                    {
                        merging(array1,array2,m,m+sublength-1,m+2*sublength-1);
                    }
                    else
                    {
                        merging(array2,array1,m,m+sublength-1,m+2*sublength-1);
                    }
                }
                else
                {
                    if(count%2!=0)
                    {
                        merging(array1,array2,m,m+sublength-1,length-1);
                    }
                    else
                    {
                        merging(array2,array1,m,m+sublength-1,length-1);
                    }
                }
                m = m+2*sublength;
            }
            count++;
            sublength = sublength*2;
        }
        if(count%2!=0)
        {
            array2 = array1;
        }
    }


    private void merging(int[] array1,int[] array2,int low,int mid,int high)
    {
        int i = low;
        int j = mid+1;
        int k =low;
        for(; i<=mid&&j<=high;k++)
        {
            if(array1[i]<array1[j])
            {
                array2[k] = array1[i];
                i++;
            }
            else
            {
                array2[k] = array1[j];
                j++;
            }
        }
        if(i<=mid)
        {
            for(;i<=mid;i++ )
            {
                array2[k] = array1[i];
                k++;
            }
        }
        if(j<=high)
        {
            for(;j<=high;j++)
            {
                array2[k] = array1[j];
                k++;
            }
        }
    }

    public void sort_Recursion()
    {

    }

    public void print()
    {
        for(int i=0;i<array2.length;i++)
        {
            System.out.print(array2[i]+"     ");
        }
    }

    public static void main(String args[])
    {
        int[] array = {23,24,23,54,35,54,76,36,48,95,20,54};
        MergingSort merginArray = new MergingSort(array);
        merginArray.sort();
        merginArray.print();
    }