十大排序算法性能测试

直接上代码

package sort;

import java.util.*;

// 排序算法测试类,单位（纳秒）
abstract class Accumulator {
   
    public static final int MAX_NUM = 5000;  // 数组中数值不超过该值，计数排序/桶排序需要需要
    public static int size = 10;    // 默认大小
    public static List<Accumulator> dump = new ArrayList<Accumulator>();

    protected String id = "error";
    protected long duration = 0;

    public abstract void sort(int[] arr);

    public static void timedTest(Accumulator acc) {
   
        int[] array = getRandomNumbers();  // 获取未排序的数组
        long start = System.nanoTime();
        acc.sort(array);
        acc.duration = System.nanoTime() - start;   // 记录执行时间，单位(毫秒)
        System.out.print(String.format("%-13s: %13d\n", acc.id, (int) (acc.duration)));
        dump.add(acc);  // 保存测试记录
    }

    // 输出测试排名
    public static void report() {
   
        Collections.sort(dump, new Comparator<Accumulator>() {
   
            @Override
            public int compare(Accumulator o1, Accumulator o2) {
   
                return (int) (o1.duration - o2.duration);
            }
        });
        for (Accumulator acc : dump) {
   
            System.out.print(acc.id + " > ");
        }
        System.out.println();
    }

    // 生成随机数组
    public static int[] getRandomNumbers() {
   
        Random rand = new Random(47);
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
   
            arr[i] = rand.nextInt(Accumulator.MAX_NUM);
        }
        return arr;
    }

    public void swap(int[] arr, int i, int j) {
   
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

/**
 * 1、冒泡排序O(N^2)
 * 相邻元素比较，较大元素向前推进
 */
class BubbleSort extends Accumulator {
   
    {
   
        id = "bubbleSort";
    }

    @Override
    public void sort(int[] arr) {
   
        for (int i = 1; i < arr.length; i++) {
   
            for (int j = 0; j < arr.length - i; j++) {
   
                if (arr[j] > arr[j + 1]) {
   
                    swap(arr, j, j + 1);
                }
            }
        }
    }
}

/**
 * 2、选择排序O(N^2)
 * 按顺序循环找到最小(大)元素，存放到序列起始位置
 * 然后在从剩余未排序元素继续此操作
 */
class SelectionSort extends Accumulator {
   
    {
   
        id = "selectionSort";
    }

    @Override
    public void sort(int[] arr) {
   
        for (int i = 0; i < arr.length; i++