数据结构：常见排序算法(4) --归并排序（递归 &&非递归）及排序总结

（1）归并排序

①原理

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子 序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

②代码实现

递归实现：

public class MergeSort {
    public static void main(String[] args) {
        int[] array={5,1,4,8,14,56,0,12,47,50};
        System.out.println(Arrays.toString(array));
        mergeSort(array);
        System.out.println(Arrays.toString(array));
    }

    //递归
    public static void mergeSortInternal(int[] array,int low,int high){
        if(low>=high) return;
        int mid=(low+high)/2;
        mergeSortInternal(array,low,mid); //递归实现
        mergeSortInternal(array,mid+1,high);  //递归实现
        //合并操作
        merge(array,low,mid,high);
    }

    //合并
    private static void merge(int[] array,int start,int mid,int end) {
        int s1=start;
        int s2=mid+1;
        int[] tmp=new int[end-start+1];
        int k=0; //tmp数组的下标
        while(s1<=mid  && s2<=end){
            if(array[s1]<array[s2]){
                tmp[k++]=array[s1++];
            }else{
                tmp[k++]=array[s2++];
            }
        }
        //有可能第一个段还有数据
        while(s1<=mid){
            tmp[k++]=array[s1++];
        }
        //有可能第二个段还有数据
        while(s2<=end){
            tmp[k++]=array[s2++];
        }
        for (int i = 0; i < tmp.length; i++) {
            array[i+start]=tmp[i];
        }
    }

    //归并排序
    public static void mergeSort(int[] array){
        mergeSortInternal(array,0,array.length-1);
    }
}

运行截图：

非递归实现：

public class MergeSort {
    //归并排序的非递归实现
    public static void main(String[] args) {
        int[] array={4,12,8,5,6,65,0,10,41,2};
        System.out.println(Arrays.toString(array));
        mergeSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void mergeSort(int[] array){
        for(int i=1;i<array.length;i++){
            merge(array,i);
        }
    }
    //合并
    public static void merge(int[] array,int gap){
        int s1=0, e1=s1+gap-1, s2=e1+1, e2=s2+gap-1 < array.length ? s2+gap-1:array.length-1;
        //当有两个归并段的时候
        int[] tmp=new int[array.length];
        int k=0;
        while(s2<array.length){
            while(s1<=e1 && s2<=e2){
                if(array[s1]<=array[s2]){
                    tmp[k++]=array[s1++];
                }else{
                    tmp[k++]=array[s2++];
                }
            }
            //有可能第一个段还有数据
        while(s1<=e1){
            tmp[k++]=array[s1++];
        }
        //有可能第二个段还有数据
        while(s2<=e2){
            tmp[k++]=array[s2++];
        }
        s1=e2+1;
        e1=s1+gap-1;
        s2=e1+1;
        e2=s2+gap-1<array.length ? s2+gap-1 :array.length-1;
        }
        //退出循环后，那么把s1的数据拷贝下来
        while(s1 < array.length){
            tmp[k++]=array[s1++];
        }
        for (int i = 0; i <tmp.length ; i++) {
            array[i]=tmp[i];
        }
    }
 }

运行截图：

③性能分析

稳定性：稳定

（2）排序算法的总结

性能总结：

（3）其他排序

计数排序
基数排序
桶排序