wie allgemeine Fehler in Java lösen

Question

Ich habe Methode zum schnellen Sortieralgorithmus erstellt Verwendung von Generika, ich versuche, diese Methode zu implementieren, aber ich versuche, das so wird es schnell sortiert alle Variablen mit in der Anordnung wie Zahlen zu implementieren, string, char und so weiter. Ich habe diese Klasse implementiert.

Dies ist meine AssertRayTool-Klasse.

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 

    } 
} 

Dies ist meine Quicksort-Klasse, die die oben genannte Klasse erweitert.

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

Von dem, was ich sehe, behandeln Sie Ihr generisches Array nur als ein Array von ganzen Zahlen. Um dies zu beheben, dass

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

Wird

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

Und

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

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

Wird

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

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

Auch nicht vergessen, dass Ihre T Klasse Vergleichbare implementieren müssen, die Sie sonst kann Objekte nicht vergleichen .