Javaのジェネリックエラーを解決する方法

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 

    } 
} 

これは上記のクラスを拡張したクイックソートクラスです。

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を実装しなければならないことを忘れないでくださいになりオブジェクトを比較することはできません。