排序算法之快排与归并排序

1、快速排序

适合数据量大，排序时间短，具体代码如下：

package ds.sort;


/**
 * @author : cuantianhou 2019/12/16
 */
public class QuickSort {


    /**
     * 主要思路：取基准数据，从数据高位寻找小于基准数据的值，然后用目标值替换低位置的值，
     * 然后从低位置寻找大于基准数据的值，
     *
     *
     */

    /**
     *
     * @param arr  比较的数组
     * @param start 起始位置
     * @param end 结束位置
     * @param <T> 泛型
     */
    public <T extends Comparable> void quickSort(T [] arr,int start, int end){

        if(start >= end){
            return;
        }

        //记录基准数据
        T base = arr[start];
        while(start < end){
            while(start < end && arr[end].compareTo(base)>=0) {
                end --;
            }
            arr[start] = arr[end];
            while(start < end && arr[start].compareTo(base)<=0){
                start ++;
            }
            arr[end] = arr[start];
        }
        arr[start] = base;

        quickSort(arr,0,start-1);
        quickSort(arr,start+1,end);
    }
}

2、归并排序

将数组分块排序，然后合并，完成排序，具体代码如下：

package ds.sort;


import java.lang.reflect.Array;

/**
 * @author : cuantianhou 2019/12/16
 */
public class MergeSort {

    public<T extends Comparable<T>> void mergeSort(T []arr){
        merge(arr,0,arr.length-1,arr[0].getClass());
    }

    private <T extends Comparable<T>> void merge(T []arr, int left, int right,Class<?> elementClass){
            if(left == right){
                return;
            }
            int mid = (left+right)>>1;
            merge(arr,left,mid,elementClass);
            merge(arr,mid+1,right,elementClass);
            sort(arr,left,mid,right,elementClass);
            //打印每次排序结果
            for(int l = 0; l < arr.length-1; l ++){
                System.out.print(arr[l]+",");
            }
            System.out.println(arr[arr.length-1]);
    }

    private<T extends Comparable<T>> void sort(T []arr, int left , int mid, int right, Class<?> elementClass){
        //构造一个临时数组
        T[] temp = (T[])Array.newInstance(elementClass,right-left+1);
        //记录当前索引
        int i = 0;
        int m = left;
        int n = mid + 1;
        //比较左右两个元素，哪个小，把哪个元素放入临时数组中
        while(m <= mid && n <= right){
            temp[i++] = arr[m].compareTo(arr[n])== -1 ? arr[m++]: arr[n++];
        }

        while(m<=mid){
            temp[i++] = arr[m++];
        }
        while(n<=right){
            temp[i++] = arr[n++];
        }

        //把最终的排序结果复制给原数组
        for(int j = 0; j < temp.length; j++){
            arr[left+j] = temp[j];
        }
    }
}

参考文章：https://www.jianshu.com/p/33cffa1ce613