Question

我已经使用泛型创建了快速排序算法的方法，我正在尝试实现此方法，但我正在尝试实现它，因此它将快速排序数组中的任何变量，如数字，字符串，字符等。我已经实现了这个课程。

这是我的AssertRayTool类。

package arraySorter;

import RandomArray.RandomArray;


public abstract class ArraySortTool<T extends Comparable<T>> implements ArraySort<T>
{

    private double timeTakenMillis(T[] array) {
        double startTime = System.nanoTime();
        sort(array);
        return ((System.nanoTime()-startTime)/1000000.0);
    }


    public void timeInMillis(RandomArray<T> generator,int noPerSize,int maxTimeSeconds)
    {
        int size = 1;  // initial size of array to test
        int step = 1;  // initial size increase
        int stepFactor = 10; // when size reaches 10*current size increase step size by 10
        double averageTimeTaken;
        do {
            double totalTimeTaken = 0;
            for (int count = 0; count < noPerSize; count++) {
                T[] array = generator.randomArray(size);
                totalTimeTaken += timeTakenMillis(array);
            }
            averageTimeTaken = totalTimeTaken/noPerSize;
            System.out.format("Average time to sort %d elements was %.3f milliseconds.\n",size,averageTimeTaken);
            size += step;
            if (size >= stepFactor*step) step *= stepFactor;        
        } while (averageTimeTaken < maxTimeSeconds*1000);
        System.out.println("Tests ended.");
    }


    public boolean isSorted(T[] array) {
        int detectedDirection = 0; // have not yet detected increasing or decreasing
        T previous = array[0];
        for (int index = 1; index < array.length; index++) {
            int currentDirection = previous.compareTo(array[index]); // compare previous and current entry
            if (currentDirection != 0) { // if current pair increasing or decreasing
                if (detectedDirection == 0) { // if previously no direction detected
                    detectedDirection = currentDirection; // remember current direction
                } else if (detectedDirection * currentDirection < 0) { // otherwise compare current and previous direction
                    return false; // if they differ array is not sorted
                }
            }
            previous = array[index];
        }
        // reached end of array without detecting pairs out of order
        return true;
    }

    public void sort(T[] array) {
        // TODO Auto-generated method stub

    }
}

这是我的Quicksort类，它扩展了上面的类。

    package arraySorter;

public class QuickSort<T extends Comparable<T>> extends ArraySortTool<T>


{
    private T array[];
    private int length;

    public void sort(T[] array) {

        if (array == null || array.length == 0) {
            return;
        }
        this.array = array;
        length = array.length;
        quickSort(0, length - 1);
    }

    private void quickSort(int lowerIndex, int higherIndex) {

        int i = lowerIndex;
        int j = higherIndex;
        // calculate pivot number, I am taking pivot as middle index number
        int pivot = [lowerIndex+(higherIndex-lowerIndex)/2];
        // Divide into two arrays
        while (i <= j) {

            while (array[i] < pivot) {
                i++;
            }
            while (array[j] > pivot) {
                j--;
            }
            if (i <= j) {
                exchangeValues(i, j);
                //move index to next position on both sides
                i++;
                j--;
            }
        }
        // call quickSort() method recursively
        if (lowerIndex < j)
            quickSort(lowerIndex, j);
        if (i < higherIndex)
            quickSort(i, higherIndex);
    }

    private void exchangevalues(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

}

Answer 1

从我所看到的，您只将整数数组视为整数数组。解决这个问题

int pivot = [lowerIndex+(higherIndex-lowerIndex)/2];

成为

T pivot = [lowerIndex+(higherIndex-lowerIndex)/2];

和

while (array[i] < pivot) 
    i++;

while (array[j] > pivot) {
    j--;

成为

while (array[i].compareTo(pivot) < 0) 
   i++;

while (array[j].compareTo(pivot) > 0) 
   j--;

另外，不要忘记你的T类必须实现Comparable，否则你将无法比较对象。

如何解决java中的泛型错误

1 个答案: