数据结构-返回top k个最大的数

import java.util.Arrays;

public class MaxTopK {
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean pass = true;
        System.out.println("测试开始，没有打印出错信息说明测试通过");
        for (int i = 0; i < testTime; i++) {
            int k = (int) (Math.random() * maxSize) + 1;
            int[] arr = generateRandomArray(maxSize,maxValue);

            int[] arr1 = copyArray(arr);
            int[] arr2 = copyArray(arr);

            int[] ans1 = maxTopK1(arr1,k);
            int[] ans2 = maxTopK2(arr2,k);

            if(!isEqual(ans1,ans2)){
                pass = false;
                System.out.println("出错了！");
                printArray(ans1);
                printArray(ans2);
                break;
            }
        }
        System.out.println("测试结束了，测试了" + testTime + "组，是否所有测试用例都通过？" + (pass ? "是" : "否"));
    }

    public static void printArray(int[] arr){
        if(arr == null){
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
    public static boolean isEqual(int[] arr1, int[] arr2){
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length){
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }

    public static int[] generateRandomArray(int maxSize, int maxValue){
        int[] arr = new int[(int)((maxSize+1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)((maxValue+1) * Math.random()) - (int)((maxValue) * Math.random());
        }

        return arr;
    }

    public static int[] maxTopK1(int[] arr,int k){
        if(arr == null || arr.length == 0){
            return new int[0];
        }

        int N = arr.length;
        k = Math.min(N, k);
        Arrays.sort(arr);
        int[] ans = new int[k];
        for (int i = arr.length-1,j = 0; i >= arr.length-k; i--,j++) {
            ans[j] = arr[i];
        }

        return ans;
    }

    public static int[] maxTopK2(int[] arr,int k){
        if(arr == null || arr.length == 0){
            return new int[0];
        }

        int N = arr.length;
        k = Math.min(N, k);

        int v = minKth3(arr,arr.length - k+1);
        int[] ans = new int[k];
        int j=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > v){
                ans[j++] = arr[i];
            }
        }

        for (; j < ans.length; j++) {
            ans[j] = v;
        }

        Arrays.sort(ans);
        for (int L = 0, R = k - 1; L < R; L++,R--) {
            swap(ans,L,R);
        }

        return ans;
    }

    public static int[] copyArray(int[] arr){
        int[] ans = new int[arr.length];
        for (int i = 0; i < ans.length; i++) {
            ans[i] = arr[i];
        }
        return ans;
    }

    /*
     *   bfprt算法
     *   1. 5个数一组，排序
     *   2. 把每组的中位数拿出来，再组成一个数组arr
     *   3. 取出arr数组的中位数p
     */
    public static int minKth3(int[] array, int k) {
        int[] arr = copyArray(array);
        return bfprt(arr,0,arr.length-1,k-1);
    }

    public static int bfprt(int[] arr, int L, int R, int index){
        if(L == R){
            return arr[L];
        }

        int pivot = medianOfMedians(arr, L, R);
        int[] range = partition(arr, L, R, pivot);
        if(range[0] <= index && index <= range[1]){
            return arr[index];
        }else if(index < range[0]){
            return bfprt(arr, L, range[0]-1, index);
        }else{
            return bfprt(arr,range[1]+1, R, index);
        }
    }

    // 取出中位数的中位数
    public static int medianOfMedians(int[] arr, int L, int R){
        int size = R - L + 1;
        int offset = size % 5 == 0 ? 0 : 1;
        int[] mArr = new int[size/5 + offset];
        for (int i = 0; i < mArr.length; i++) {
            int teamFirst = L + i * 5;
            mArr[i] = getMedian(arr, teamFirst, Math.min(R, teamFirst + 4));
        }
        return bfprt(mArr,0,mArr.length-1,mArr.length/2);
    }

    public static int getMedian(int[] arr, int L, int R){
        // 插入排序
        insertionSort(arr, L, R);
        return arr[(R+L)/2];
    }

    public static void insertionSort(int [] arr, int L, int R){
        for (int i = L+1; i <= R; i++) {
            for (int j = i-1; j >=L && arr[j] > arr[j+1]; j--) {
                swap(arr,j,j+1);
            }
        }
    }

    public static int[] partition(int[] arr, int L, int R, int pivot){
        int less = L - 1;
        int cur = L;
        int more = R + 1;
        while(cur < more){
            if(arr[cur] < pivot){
                swap(arr, ++less, cur++);
            }else if(arr[cur] > pivot){
                swap(arr,cur, --more);
            }else{
                cur++;
            }
        }

        return new int[]{less+1, more-1};
    }

    public static void swap(int[] arr, int i1, int i2){
        int temp = arr[i2];
        arr[i2] = arr[i1];
        arr[i1] = temp;
    }
}