Java 已找到：T[]，必需：T[]

我已经用通用方法编写了排序算法Quicksort，其中包含参数：

• 分区方法：（

  T[]数组，int-low，int-high

  ）
• 排序方法：（

  T[]数组，整数低位，整数高位

  ）

但是，当我尝试在排序方法体中执行递归时，对于数组参数，我得到以下错误：

错误的第一个参数类型。找到：“T[]”，必需：“T[]”

这是排序方法中的代码：

 if (low < high)
        { int pi = partition(array, low, high);
            Quicksort(array, low, pi-1);
            Quicksort(array, pi+1, high);
        }

---

这里涉及的两种不同的泛型方法都定义了一个类型参数

T

。

Quicksort

中的

T

没有任何界限，因此它根本不必具有可比性。但是，

分区

中的

T

需要有一个上界

compariable

。编译器错误并没有说明全部原因，但出现错误是因为

t

边界不匹配

将

T

在

Quicksort

中的绑定设置为相同的绑定

static <T extends Comparable<T>> void Quicksort(T[] array, int low, int high)

---

根据Java编码约定，类（及其构造函数）应该以大写字母开头；方法和变量应以小写字母开头。正因为如此，我想知道为什么您要调用快速排序构造函数两次。

public class DD_ObjectBinarySearcher<T> {
    //comparison count for Binary search
    static int binarycount = 0;
    //comparison count for Sequential search
    static int seqcount = 0;
    //comparison totals for calculating averages
    static int stotal; static int btotal;

    /**
     *
     * @return total counts of Sequential Search
     */
    public static int getStotal() {
        return stotal;
    }

    /**
     *
     * @return total counts of Binary Search
     */
    public static int getBtotal() {
        return btotal;
    }

    /**
     * @param array array to be sorted
     * @param low starting index
     * @param high ending index
     * @return partition for quick sort
     */
    static  <T extends Comparable<T>> int partition(T[] array, int low, int high)
    {
        T pivot = array[high];
        int i = (low-1); // index of smaller element
        for (int j=low; j<high; j++)
        {
            if (array[j].compareTo(pivot) <=0)
            {
                i++;
                // swap array[i] and array[j]
                T temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }

        // swap array[i+1] and array[high] (or pivot)
        T temp = array[i+1];
        array[i+1] = array[high];
        array[high] = temp;

        return i+1;
    }

    /**
     * @param array array to be sorted
     * @param low starting index
     * @param high ending index
     */
    static <T> void Quicksort(T[] array, int low, int high)
    {
        if (low < high)
        { int pi = partition(array, low, high);
            Quicksort(array, low, pi-1);
            Quicksort(array, pi+1, high);
        }
    }

    /**
     * @param a array
     * @param b compared integer
     * @return flag
     */
    static <T extends Comparable<T>> boolean sequentialSearch(T[] a, T b){
        for (T i : a) {
            if (i==b){
                System.out.println("The number of comparisons for unsorted array: " + seqcount);
                stotal+=seqcount;
                return true;
            }
            seqcount++;
        }
        return false;
    }

    /**
     * @param a array
     * @param b compared integer
     * @return flag
     */
    static <T extends Comparable<T>> boolean binarySearch(T[] a, T b) {
        if (a.length == 0) return false;
        int low = 0;
        int high = a.length-1;

        while(low <= high ) {
            int middle = (low+high) /2;
            if (b.compareTo((T) a[middle]) > 0){
                low = middle +1;
            } else if (b.compareTo((T) a[middle]) < 0){
                high = middle -1;
            } else { // the element has been found
                System.out.println("The number of comparisons for sorted array: " + binarycount);
                btotal+=binarycount; //totals are used to calculate average in the main
                return true;
            }
            binarycount++;
        }
        return false;
    }

    /**
     *
     * @param array that will be printed
     */
    static void printArray(int[] array)
    {
        for (int value : array) System.out.print(value + " ");
        System.out.println();
    }

}

static <T extends Comparable<T>> void Quicksort(T[] array, int low, int high)

static <T extends Comparable<? super T>> void Quicksort(T[] array, int low, int high)

class DD_ObjectBinarySearcher {