Java 在这种情况下，我如何正确使用可比数据？_Java_Algorithm_Generics

Java 在这种情况下，我如何正确使用可比数据？

java algorithm generics

Java 在这种情况下，我如何正确使用可比数据？,java,algorithm,generics,Java,Algorithm,Generics,我在做一个来自Sedgewick算法教科书的练习，这个练习是为了找到快速排序的比较次数。下面是我的代码： import edu.princeton.cs.algs4.StdOut; import edu.princeton.cs.algs4.StdRandom; import java.util.Random; public class quickSortCompareCheck { private static int numberOfCompares; private

我在做一个来自Sedgewick算法教科书的练习，这个练习是为了找到快速排序的比较次数。下面是我的代码：

import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import java.util.Random;

public class quickSortCompareCheck {

    private static int numberOfCompares;


    private static Comparable[] generateArray(int n) {
        Random random = new Random();
        Comparable[] arr = new Comparable[n];
        for (int i = 0; i < n; i++) {
            arr[i] = random.nextInt();
        }
        return arr;
    }

    private static class QuickSort {

        private static void quickSort(Comparable[] arr) {
            StdRandom.shuffle(arr);
            quickSort(arr, 0, arr.length - 1);
        }

        private static void quickSort(Comparable[] arr, int lo, int hi) {
            if (lo >= hi) return;
            int partition = partition(arr, lo, hi);
            quickSort(arr, lo, partition - 1);
            quickSort(arr, partition + 1, hi);
        }

        private static int partition(Comparable[] arr, int lo, int hi) {
            Comparable pivot = arr[lo];
            int i = lo;
            int j = hi + 1;
            while (true) {
                numberOfCompares++;

                while (less(arr[++i], pivot)) {
                    if (i == hi) break;
                    numberOfCompares++;
                }

                numberOfCompares++;

                while(less(pivot, arr[--j])) {
                    if (j == lo) break;
                    numberOfCompares++;
                }

                if (i >= j) break;
                exchange(arr, i, j);
            }
            exchange(arr, lo, j);
            return j;
        }

        private static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }

        private static void exchange(Comparable[] arr, int i, int j) {
            Comparable temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }


    }


    public static void main(String[] args) {
        int[] sizes = {100,1000,10000};
        for (int i = 0; i < sizes.length; i++) {
            int size = sizes[i];
            double exp = 2 * size * Math.log(size);
            Comparable[] arr = generateArray(sizes[i]);
            QuickSort.quickSort(arr);
            StdOut.println("Expected compares is: " + exp);
            StdOut.println("Actual compares is: " + numberOfCompares);
            numberOfCompares = 0;
        }
        
    }
}

导入edu.princeton.cs.algs4.StdOut；
导入edu.princeton.cs.algs4.StdRandom；
导入java.util.Random；
公共类QuickPortCompareCheck{
私有静态整数比较；
专用静态可比[]发电机阵列（int n）{
随机=新随机（）；
可比[]arr=新的可比[n]；
对于（int i=0；i=hi）返回；
int partition=分区（arr、lo、hi）；
快速排序（arr、lo、分区-1）；
快速排序（arr，分区+1，hi）；
}
专用静态整型分区（可比[]arr、整型lo、整型hi）{
可比枢轴=arr[lo]；
int i=lo；
int j=hi+1；
while（true）{
numberof++；
而（小于（arr[++i]，枢轴））{
如果（i==hi）中断；
numberof++；
}
numberof++；
而（小于（枢轴，arr[--j]））{
如果（j==lo）中断；
numberof++；
}
如果（i>=j）断裂；
交换（arr，i，j）；
}
交换（arr、lo、j）；
返回j；
}
私有静态布尔值小于（可比v，可比w）{
将v.compare返回到（w）<0；
}
私有静态无效交换（可比[]arr，int i，int j）{
可比温度=arr[i]；
arr[i]=arr[j]；
arr[j]=温度；
}
}
公共静态void main（字符串[]args）{
int[]大小={100100010000}；
对于（int i=0；i


我得到以下错误：
quickSortCompareCheck.java:10: warning: [rawtypes] found raw type: Comparable
    private static Comparable[] generateArray(int n) {
                   ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:12: warning: [rawtypes] found raw type: Comparable
        Comparable[] arr = new Comparable[n];
        ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:12: warning: [rawtypes] found raw type: Comparable
        Comparable[] arr = new Comparable[n];
                               ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:21: warning: [rawtypes] found raw type: Comparable
        private static void quickSort(Comparable[] arr) {
                                      ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:26: warning: [rawtypes] found raw type: Comparable
        private static void quickSort(Comparable[] arr, int lo, int hi) {
                                      ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:33: warning: [rawtypes] found raw type: Comparable
        private static int partition(Comparable[] arr, int lo, int hi) {
                                     ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:34: warning: [rawtypes] found raw type: Comparable
            Comparable pivot = arr[lo];
            ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:59: warning: [rawtypes] found raw type: Comparable
        private static boolean less(Comparable v, Comparable w) {
                                    ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:59: warning: [rawtypes] found raw type: Comparable
        private static boolean less(Comparable v, Comparable w) {
                                                  ^
  missing type arguments for generic class Comparable<T>
  where T is a type-variable:
    T extends Object declared in interface Comparable
quickSortCompareCheck.java:60: warning: [unchecked] unchecked call to compareTo(T) as a member of the raw type Comparable
            return v.compareTo(w) < 0;
                              ^
  where T is a type-variable:
    T extends Object declared in interface Comparable
10 warnings

quickSortCompareCheck.java:10:警告：[rawtypes]找到原始类型：Comparable
专用静态可比[]发电机阵列（int n）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:12:警告：[rawtypes]找到原始类型：Comparable
可比[]arr=新的可比[n]；
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:12:警告：[rawtypes]找到原始类型：Comparable
可比[]arr=新的可比[n]；
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:21:警告：[rawtypes]找到原始类型：Comparable
专用静态void快速排序（可比[]arr）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:26:警告：[rawtypes]找到原始类型：Comparable
专用静态void快速排序（可比[]arr、int lo、int hi）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:33:警告：[rawtypes]找到原始类型：Comparable
专用静态整型分区（可比[]arr、整型lo、整型hi）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:34:警告：[rawtypes]找到原始类型：Comparable
可比枢轴=arr[lo]；
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:59:警告：[rawtypes]找到原始类型：Comparable
私有静态布尔值小于（可比v，可比w）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:59:警告：[rawtypes]找到原始类型：Comparable
私有静态布尔值小于（可比v，可比w）{
^
泛型类“”缺少类型参数
其中T是一个类型变量：
T扩展接口中声明的对象
quickSortCompareCheck.java:60:警告：[未选中]未选中调用compareTo（T）作为原始类型Comparable的成员
将v.compare返回到（w）<0；
^
其中T是一个类型变量：
T扩展接口中声明的对象
10个警告

我对Java非常陌生，我不确定如何修复代码，我使用Integer类而不是Comparable来实现它，因为Integer实现了Comparable，但我希望让我的代码按原样工作