各个排序算法 | Java实现

最新推荐文章于 2022-04-24 10:26:04 发布

onemsg 徽章

最新推荐文章于 2022-04-24 10:26:04 发布

阅读量256

点赞数

分类专栏：数据结构和算法文章标签：排序算法快速排序

本文链接：https://blog.csdn.net/onedayilove/article/details/104645249

版权

本文介绍了多种排序算法的Java实现，包括插入排序、希尔排序、归并排序、快速排序、桶排序、基数排序、堆排序和并行排序。特别提到快速排序在处理大量数据时表现优秀，而桶排序在特定场景下能实现常数时间复杂度。同时，文章提供了一个多线程的排序算法，但其速度有待优化。作者推荐马克·艾伦·维斯的《数据结构与算法：Java语言描述》作为算法学习参考，并建议在日常Java开发中使用Arrays.sort()或Arrays.parallelSort()进行排序。

摘要由CSDN通过智能技术生成

代码实现细节几乎照抄 马克·艾伦·维斯 一书 😂《数据结构与算法：Java语言描述》，算法分析强烈推荐此书。

不过自己写的工具类和测试类挺好用的😊，还写了一个多线程的排序算法（子线程用的快排），测试出的速度没单独的快排快😭，需要优化下🛠🛠。

主内容

源码

Sort

package com.onemsg.algorithm.sort;

/**
 * Sort 为了方便测试而加入的函数式接口
 */
@FunctionalInterface
public interface Sort {

    long[] sort(long[] array);
}

Sorts

package com.onemsg.algorithm.sort;

/**
 * Sort
 */

public interface Sorts {

    static long[] sort(long[] array){
        if(array.length < 100 ){
            return InsertionSort.sort(array);
        }else if(array.length < 10000){
            return ShellSort.sort(array);
        }else{
            return QuickSort.sort(array);
        }
    }
    
}

InsertionSort

package com.onemsg.algorithm.sort;

import java.lang.reflect.Array;

/**
 * InsertionSort 插入排序
 */
public class InsertionSort{

    private InsertionSort(){
        
    }

    public static long[] sort(long[] array){
        return sort(array, true);
    }

    public static double[] sort(double[] array){
        return sort(array, true);
    }

    public static <T extends Comparable<? super T>> T[] sort(T[] array){
        return sort(array, true);
    }

    public static long[] sort(long[] array, boolean replace){

        long[] arr = array; 
        if(!replace){   //如果不替换原数组，则拷贝一份原数组
            arr = new long[array.length];
            System.arraycopy(array, 0, arr, 0, array.length);
        }

        int j;
        for(int i = 1; i < arr.length; i++){
            long tmp = arr[i];
            for(j = i; j > 0 && tmp < arr[j-1]; j--){
                arr[j] = arr[j-1];
            }
            arr[j] = tmp;
        }

        return arr;
    }

    public static double[] sort(double[] array, boolean replace){

        double[] arr = array;
        if (!replace) { // 如果不替换原数组，则拷贝一份原数组
            arr = new double[array.length];
            System.arraycopy(array, 0, arr, 0, array.length);
        }

        int j;
        for (int i = 1; i < arr.length; i++) {
            double tmp = arr[i];
            for (j = i; j > 0 && tmp < arr[j - 1]; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = tmp;
        }

        return arr;
    }

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> T[] sort(T[] array, boolean replace){

        T[] arr = array;
        if (!replace) { // 如果不替换原数组，则拷贝一份原数组
            arr = (T[]) Array.newInstance(arr[0].getClass(), array.length);
            System.arraycopy(array, 0, arr, 0, array.length);
        }

        int j;
        for (int i = 1; i < arr.length; i++) {
            T tmp = arr[i];
            for (j = i; j > 0 && tmp.compareTo(arr[j-1]) < 0; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = tmp;
        }

        return arr;
    }
}

ShellSort

package com.onemsg.algorithm.sort;

import java.lang.reflect.Array;

/**
 * ShellSort 希尔排序
 */
public class ShellSort {

    private ShellSort(){

    }

    public static long[] sort(long[] array) {
        return sort(array, true);
    }

    public static double[] sort(double[] array) {
        return sort(array, true);
    }

    public static <T extends Comparable<? super T>> T[] sort(T[] array) {
        return sort(array, true);
    }

    public static long[] sort(long[] array, boolean replace){
        long[] arr = array; 
        if(!replace){   //如果不替换原数组，则拷贝一份原数组
            arr = new long[array.length];
            System.arraycopy(array, 0, arr, 0, array.length);
        }

        int j;
        int[] seq = getHibbardSequence(array);
        for(int gap : seq){
            for(int i = gap; i < arr.length; i++){
                long tmp = arr[i];
                for (j = i; j >= gap && tmp < arr[j - gap]; j -= gap) {
                    arr[j] = arr[j - gap];
                }
                arr[j] = tmp;
            }
        }
    
        return arr;
    }

    public static double[] sort(double[] array, boolean replace){
        double[] arr = array; 
        if(!replace){   //如果不替换原数组，则拷贝一份原数组
            arr = new double[array.length];
            System.arraycopy(array, 0, arr, 0, array.length);
        }

        int j;
        int[] seq = getHibbardSequence(array);
        for(int gap : seq){
            for(int i = gap; i < arr.length; i++){
                double tmp = arr[i];
                for (j = i; j >= gap && tmp < arr[j - gap]; j -= gap) {
                    arr[j] = arr[j - gap];
                }
                arr[j] = tmp;
            }
        }
    
        return arr;
    }

    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> T[] sort(T[] array, boolean replace){

        T[] arr &#