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 

    } 
} 

위의 클래스를 확장 한 내 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

일반 배열을 정수 배열로만 처리하는 것을 볼 수 있습니다. 당신이 그렇지 않으면 T 클래스가 Comparable를 구현해야한다는 것을 잊지 마세요,

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--; 

을 일으킬 수 있으므로 것을 해결하려면 객체를 비교할 수 없습니다. .