排序--归并排序

算法思想

1，申请空间，使其大小为2个已经排序的数列之和，该空间用来存放合并后的序列。

2，设定2个指针，最初位置为2个已经排序数列的的起始位置。

3，比较2个指针所指向的元素，选择较小的元素放入合并空间，并移动指针到下个位置。

4，重复步骤3，知道某一个指针到达数列尾部。

5，将另一个数列的剩余元素全部复制到合并空间。

归并排序原理

归并排序具体工作原理如下（假设序列共有n个元素）：

1. 将序列每相邻两个数字进行归并操作，形成个序列，排序后每个序列包含两个元素
2. 将上述序列再次归并，形成个序列，每个序列包含四个元素
3. 重复步骤2，直到所有元素排序完毕

归并排序原理代码

/**
 *归并排序的原理Demo：
 * 1，申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
 * 2， 设定两个指针，最初位置分别为两个已经排序序列的起始位置
 * 3， 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
 * 4，重复步骤3直到某一指针达到序列尾
 * 5，将另一序列剩下的所有元素直接复制到合并序列尾 
 *
 */
public class Merge
{

    public static int[] mergeSort(int[] A,int[] B){
        //申请空间，大小等于2个已经排序的数列之和
        int[] C = new int[A.length+B.length];
        //指针i，j分别指向2个数列的起始位置。
        int i=0,j=0,k=0;
        //比较2个指针所指向的元素，将较小的元素放入到合并空间，并移动指针。
        while(i<A.length && j<B.length){
            if(A[i] < B[j])
                C[k++] = A[i++];
            else
                C[k++] = B[j++];
        }
        //将另一个序列的元素全部复制到合并空间尾部
        //以下2个while只会执行其中一个
        while(i<A.length){
            C[k++] = A[i++];
        }
        while(j<B.length){
            C[k++] = B[j++];
        }
        return C;
    }
    public static void main(String[] args)
    {
        int[] A = {1,3,5,7,9,11};
        int[] B = {2,4,6,8,10,12};
        int[] C =mergeSort(A, B);
        for(int i: C)
        {
            System.out.print(i+" ");
        }
    }
}

Java 实现代码

public class Merge
{

    public static void main(String[] args)
    {
        Integer[] arr = {5,3,4,6,3,1,4,6,5,36,5,44,22,88,99,5,555,3335,64,544,22333};
        merge(arr);
        for(Integer i: arr)
        {
            System.out.print(i + " ");
        }
    }

    @SuppressWarnings("unchecked")
    private static <T extends Comparable<? super T>> void merge(T[] arr)
    {
        T[] temArr = (T[])new Comparable[arr.length];
        mergeSort(arr, temArr, 0, arr.length - 1);
    }

    private static <T extends Comparable<? super T>> void mergeSort(T[] arr, T[] temArr, int left, int right)
    {
        if(left < right)
        {//递归
            int center = (left + right) / 2;
            mergeSort(arr, temArr, left, center);
            mergeSort(arr, temArr, center + 1, right);
            merge(arr, temArr, left, center + 1, right);
        }
    }

    private static <T extends Comparable<? super T>> void merge(T[] arr, T[] temArr, int leftPos, int rightPos, int rightEnd)
    {
        // 左边数列的最大索引
        int leftEnd = rightPos - 1;
        // 合并空间的起始索引
        int temPos = leftPos;
        // 用于复制最终数组用的左边数列的起始指针
        int temLeft = leftPos;
        // 比较2个指针所指的元素的大小，将小的赋值给临时空间对应的位置。指针移动一个位置，继续比较。直到一个数列结尾。
        while(leftPos <= leftEnd && rightPos <= rightEnd)
        {
            if(arr[leftPos].compareTo(arr[rightPos]) <= 0)
            {
                temArr[temPos++] = arr[leftPos++];
            }
            else
            {
                temArr[temPos++] = arr[rightPos++];
            }
        }
        // 将另外一个数列全部复制到临时空间
        while(leftPos <= leftEnd)
        {
            temArr[temPos++] = arr[leftPos++];
        }
        while(rightPos <= rightEnd)
        {
            temArr[temPos++] = arr[rightPos++];
        }
        // 将临时空间的值复制到对应位置的原来数组
        for(int i = temLeft; i <= rightEnd; i++)
        {
            arr[i] = temArr[i];
        }
    }
}