一个使用快排结合桶排的排序案例

桶排是一种空间换时间的排序算法，在数据范围小、数据量大的场景下，效率非常高，可以达到O(n)的时间复杂度。快排是我们平时较为常用的排序算法，最好情况下，时间复杂度可以达到O(nlogn)，适用于大数据量的排序。
极客时间的算法课，在讲跳表数据结构的时候，有一道思考题。有n个url及其访问量，如何对其进行排序并倒序输出。用桶排加快排实现一下。这里完成一下这道思考题

package mechanical.list;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class AppTestCommon {
    /**
     * @param args
     */
    public static void main(String[] args) {
        List<UrlComponent> list = getUrlComponentList();
        int min = list.get(0).getCount();
        int max = list.get(1).getCount();
        //求最大、最小值。计算桶的数量时使用
        for (int i = 0; i < list.size(); i++) {
            Integer count = list.get(i).getCount();
            if (count < min) {
                min = count;
            }
            if (count > max) {
                max = count;
            }
        }
        UrlComponent[] urlComponents = new UrlComponent[list.size()];
        list.toArray(urlComponents);
        //如果数据规模,最大和最小差值小于100时使用桶排序,否则使用快速排序
        if ((max - min) < 100) {
            bucketSort(urlComponents, 5, min, max);
        } else {
            quickSortC(urlComponents, 0, urlComponents.length - 1);
        }
        for (int i = 0; i < urlComponents.length; i++) {
            System.out.println(urlComponents[i]);
        }
    }

    /**
     * 测试数据
     * @return
     */
    private static List<UrlComponent> getUrlComponentList() {
        UrlComponent url1 = UrlComponent.builder().url("http://127.0.0.1").count(10).build();
        UrlComponent url2 = UrlComponent.builder().url("http://127.0.0.2").count(9).build();
        UrlComponent url3 = UrlComponent.builder().url("http://127.0.0.3").count(8).build();
        UrlComponent url4 = UrlComponent.builder().url("http://127.0.0.4").count(21).build();
        UrlComponent url5 = UrlComponent.builder().url("http://127.0.0.5").count(25).build();
        UrlComponent url6 = UrlComponent.builder().url("http://127.0.0.6").count(21).build();
        UrlComponent url7 = UrlComponent.builder().url("http://127.0.0.7").count(18).build();
        UrlComponent url8 = UrlComponent.builder().url("http://127.0.0.8").count(16).build();
        UrlComponent url9 = UrlComponent.builder().url("http://127.0.0.9").count(15).build();
        UrlComponent url10 = UrlComponent.builder().url("http://127.0.0.10").count(13).build();
        UrlComponent url11 = UrlComponent.builder().url("http://127.0.0.11").count(20).build();
        UrlComponent url12 = UrlComponent.builder().url("http://127.0.0.12").count(26).build();
        List<UrlComponent> list = new ArrayList<>();
        list.add(url1);
        list.add(url2);
        list.add(url3);
        list.add(url4);
        list.add(url5);
        list.add(url6);
        list.add(url7);
        list.add(url8);
        list.add(url9);
        list.add(url10);
        list.add(url11);
        list.add(url12);
        return list;
    }

    /**
     * 桶排
     *
     * @param urlComponents 待排序数组
     * @param bucketSize    桶大小
     * @param min           待排序数据最大值
     * @param max           待排序数据最小值
     */
    private static void bucketSort(UrlComponent[] urlComponents, int bucketSize, int min, int max) {
        //不需要排序的情况
        if (Objects.isNull(urlComponents) || urlComponents.length == 0 || urlComponents.length == 1) {
            return;
        }
        //桶数量
        int bucketCount = (max - min) / bucketSize + 1;
        //初始化桶容器
        UrlComponent[][] buckets = new UrlComponent[bucketCount][bucketSize];
        //桶计数器
        int[] arrIndex = new int[bucketCount];
        //将待排序数组中的数据放入桶中
        for (int i = 0; i < urlComponents.length; i++) {
            //计算数据应该放哪个桶
            int bucketIndex = (urlComponents[i].getCount() - min) / bucketSize;
            //判断桶是否需要扩容
            if (arrIndex[bucketIndex] == buckets[bucketIndex].length) {
                //扩容
                ensureCapacity(buckets, bucketIndex);
            }
            //将数据放入对应的桶
            buckets[bucketIndex][arrIndex[bucketIndex]++] = urlComponents[i];
        }
        //使用快排对各个桶中的数据进行排序
        for (int i = 0; i < buckets.length; i++) {
            quickSortC(buckets[i], 0, arrIndex[i] - 1);
        }
        int k = 0;
        //倒序取出元素
        for (int i = buckets.length - 1; i > -1; i--) {
            UrlComponent[] bucket = buckets[i];
            for (int j = arrIndex[i] - 1; j > -1; j--) {
                urlComponents[k++] = bucket[j];
            }
        }
    }

    private static void quickSortC(UrlComponent[] bucket, int p, int r) {
        if (p >= r) {
            return;
        }
        int q = partition(bucket, p, r);
        quickSortC(bucket, p, q - 1);
        quickSortC(bucket, q + 1, r);
    }

    private static int partition(UrlComponent[] bucket, int p, int r) {
        UrlComponent pivot = bucket[r];
        int i = p;
        for (int j = p; j < r; j++) {
            if (bucket[j].getCount() <= pivot.getCount()) {
                swap(bucket, i, j);
                i++;
            }
        }
        swap(bucket, i, r);
        return i;
    }

    private static void swap(UrlComponent[] bucket, int i, int j) {
        UrlComponent temp = bucket[i];
        bucket[i] = bucket[j];
        bucket[j] = temp;
    }

    /**
     * 桶扩容
     *
     * @param buckets
     * @param bucketIndex
     */
    private static void ensureCapacity(UrlComponent[][] buckets, int bucketIndex) {
        UrlComponent[] tempBucket = buckets[bucketIndex];
        UrlComponent[] newBucket = new UrlComponent[tempBucket.length * 2];
        for (int i = 0; i < tempBucket.length; i++) {
            newBucket[i] = tempBucket[i];
        }
        buckets[bucketIndex] = newBucket;
    }