有一個程序，我想融合合併排序，但這樣做有困難

我有三類程序，需要一堆數據並使用比較器對其進行排序。我做的是我在名爲EarthquakeDataSet的類的最後添加了合併排序。合併被添加下來，有一個與int數組一起工作。我想要做的是與來自EarthquakeRecord的參考數組一起工作。然後我需要比較來處理它。合併開始於private int []數據的類EarthquakeDataSet的末尾。任何建議，將不勝感激有一個程序，我想融合合併排序，但這樣做有困難

import java.io.File; 
import java.io.FileNotFoundException; 
import java.io.IOException; 

import javax.swing.JFileChooser; 
import javax.swing.JOptionPane; 


public class EarthquakeTest { 
public static void main(String[] args) { 
    EarthquakeDataSet eqds = new EarthquakeDataSet(); 
    String sFileName = null; 
    try { 
     File file; 
     JFileChooser fc = new JFileChooser("."); 
     fc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); 
     int returnVal = fc.showOpenDialog(null); 
     if (returnVal == JFileChooser.APPROVE_OPTION) { 
      file = fc.getSelectedFile(); 

      long lElapseTime = eqds.loadDataFromFile(file);// open file and parse all data into <i>EarthquakeRecord</i> objects 
      System.out.println("File Loading/Parsing: Elapsed time: " + ((float) lElapseTime)/1000.0); 

      lElapseTime = eqds.copyOriginalArray(); 
      System.out.println("Create 3 copies of arrays: Elapse Time: " + ((float) lElapseTime)/1000.0); 

      eqds.sortNativeJava(); // a batch process akin to the Google batch process of building a planetary index of the internet 

      System.out.println("Data After Sorting with Native Java Sort"); 
      while (JOptionPane.showConfirmDialog(null, "Display Sorted View?") == 0) 
       eqds.display(); // allow user to view the data multiple times and view the outcome of the sort: akin to Google users performing lookups 
     } 
    } catch (FileNotFoundException fnfe) { 
     JOptionPane.showMessageDialog(null, "File not found: " + sFileName); 
    } catch (IOException ioe) { 
     JOptionPane.showMessageDialog(null, "IO Exception: " + sFileName); 
    } catch (Exception e) { 
     JOptionPane.showMessageDialog(null, "ERROR: General Exception"); 
     e.printStackTrace(); 
    } 
} 
}

import java.util.Comparator; 



public class EarthquakeRecord { 
private int nYear; 
private int nMonth; 
private int nDay; 
private int nHour; 
private int nMinute; 
private double dSecond; 
private int nUTC; 
private double dLatitude; 
private double dLongitude; 
private double dMagnitude; 
private int nDepth; 
private int nEpicentre; 
private double dCityLatitude; 
private double dCityLongitude; 
private String sCityName; 

public EarthquakeRecord(String sRawRecord) { parseStringInput(sRawRecord); } 


private void parseStringInput(String sRawRecord) { 
    try { 
     nYear = Integer.parseInt(sRawRecord.substring(0, 4)); 
    } catch (java.lang.NumberFormatException e) { 
     nYear = 0; 
    } 
    try { 
     nMonth = Integer.parseInt((sRawRecord.substring(5, 7)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nMonth = 0; 
    } 
    try { 
     nDay = Integer.parseInt((sRawRecord.substring(8, 10)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nDay = 0; 
    } 
    try { 
     nHour = Integer.parseInt((sRawRecord.substring(11, 13)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nHour = 0; 
    } 
    try { 
     nMinute = Integer.parseInt((sRawRecord.substring(14, 16)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nMinute = 0; 
    } 
    try { 
     dSecond = Double.parseDouble((sRawRecord.substring(17, 21)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dSecond = 0.0; 
    } 
    try { 
     nUTC = Integer.parseInt((sRawRecord.substring(23, 25)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nUTC = 0; 
    } 
    try { 
     dLatitude = Double.parseDouble((sRawRecord.substring(30, 37)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dLatitude = 0.0; 
    } 
    try { 
     dLongitude = Double.parseDouble((sRawRecord.substring(38, 46)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dLongitude = 0.0; 
    } 
    try { 
     dMagnitude = Double.parseDouble((sRawRecord.substring(46, 49)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dMagnitude = 0.0; 
    } 
    try { 
     nDepth = Integer.parseInt((sRawRecord.substring(50, 54)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nDepth = 0; 
    } 
    try { 
     nEpicentre = Integer.parseInt((sRawRecord.substring(56, 61)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     nEpicentre = 0; 
    } 
    try { 
     dCityLatitude = Double.parseDouble((sRawRecord.substring(62, 71)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dCityLatitude = 0.0; 
    } 
    try { 
     dCityLongitude = Double.parseDouble((sRawRecord.substring(72, 81)).trim()); 
    } catch (java.lang.NumberFormatException e) { 
     dCityLongitude = 0.0; 
    } 
    sCityName = sRawRecord.substring(93, 124).trim(); 
} 
public int getYear() { return nYear; } 
public int getMonth() { return nMonth; } 
public int getDay() { return nDay; } 
public int getHour() { return nHour; } 
public int getMinute() { return nMinute; } 
public double getSecond() { return dSecond; } 
public int getUTC() { return nUTC; } 
public double getLatitude() { return dLatitude; } 
public double getLongitude() { return dLongitude; } 
public double getMagnitude() { return dMagnitude; } 
public int getDepth() { return nDepth; } 
public int getEpicentre() { return nEpicentre; } 
public double getCityLatitude() { return dCityLatitude; } 
public double getCityLongitude() { return dCityLongitude; } 
public String getCityName() { return sCityName; } 

public String toString() { 
    return String.format("%4d/%2d/%2d %2d:%2d:%2.1f %d Lat/Long:%6.2f,%6.2f Mag:%3.1f  Depth:%4d %5d %6.2f:%6.2f %s", nYear, nMonth, nDay, nHour, nMinute, dSecond, nUTC,  dLatitude, dLongitude, 
     dMagnitude, nDepth, nEpicentre, dCityLatitude, dCityLongitude, sCityName); 
} 
public static class CompareMagnitude implements Comparator<EarthquakeRecord> { 
    public final static CompareMagnitude instance = new CompareMagnitude(); 
    public int compare(EarthquakeRecord arg0, EarthquakeRecord arg1) { 
     if(arg0.dMagnitude < arg1.dMagnitude){ 
     return(-1); 
     } 
     else if(arg0.dMagnitude > arg1.dMagnitude){ 
     return(1); 
     } 
     else{ 
     return(0); 
     } 
    } 
} 

/** Singleton public static inner class that creates a <i>Comparator</i> object if needed; used to compare <i>EarthquakeRecord</i> objects based on <i>String</i> containing City Name */ 
// TODO implement the following class 
public static class CompareCity implements Comparator<EarthquakeRecord> { 
    public final static CompareCity instance = new CompareCity(); 
    public int compare(EarthquakeRecord arg0, EarthquakeRecord arg1) {return arg0.sCityName.compareTo(arg1.sCityName);} 
} 
/** Singleton public static inner class that creates a <i>Comparator</i> object if needed; used to compare <i>EarthquakeRecord</i> objects based on <i>nDepth</i> */ 
// TODO implement the following class 
public static class CompareDepth implements Comparator<EarthquakeRecord> { 
    public final static CompareDepth instance = new CompareDepth(); 
    public int compare(EarthquakeRecord arg0, EarthquakeRecord arg1) { 
     if(arg0.nDepth < arg1.nDepth){ 
     return(-1); 
     } 
     else if(arg0.nDepth > arg1.nDepth){ 
     return(1); 
     } 
     else{ 
     return(0); 
     } 
    } 


}}

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.Arrays; 
import java.util.Comparator; 
import java.util.Scanner; 
import javax.swing.JOptionPane; 


public class EarthquakeDataSet<aeqrDepthSort> { 

private int nNumRecordsLoaded; 

private EarthquakeRecord[] aeqrOriginalOrder; 

private EarthquakeRecord[] aeqrCitySort; 

private EarthquakeRecord[] aeqrDepthSort; 

private EarthquakeRecord[] aeqrMagnitudeSort; 

public EarthquakeDataSet() { } 


public long loadDataFromFile(File file) throws FileNotFoundException, Exception { 
    Scanner scanInput = new Scanner(file); 
    int nMaxNumRecords; 
    do { 
     nMaxNumRecords = Integer.parseInt(JOptionPane.showInputDialog("Maximum  Number of Records: ")); 
    } while (nMaxNumRecords <= 0); 

    nNumRecordsLoaded = 0; 
    long lStartTime = System.currentTimeMillis(); 
    aeqrOriginalOrder = new EarthquakeRecord[nMaxNumRecords]; 
    try { 
     while (nNumRecordsLoaded < nMaxNumRecords && scanInput.hasNext()) { 
      String sRawRecord = scanInput.nextLine(); 
aeqrOriginalOrder[nNumRecordsLoaded++] = new EarthquakeRecord(sRawRecord); 
     } 
    } catch (Exception e) { 
     throw new Exception("Input failure at record: " + nNumRecordsLoaded); 
    } finally { 
     scanInput.close(); 
    } 
    System.out.printf("Number Records Loaded: %d", nNumRecordsLoaded); 
    return System.currentTimeMillis() - lStartTime; 
} 
public long copyOriginalArray() { 

    long lStartTime = System.currentTimeMillis(); 

    aeqrCitySort = Arrays.copyOf(aeqrOriginalOrder, aeqrOriginalOrder.length); 

    aeqrMagnitudeSort = Arrays.copyOf(aeqrOriginalOrder, aeqrOriginalOrder.length); 

    aeqrDepthSort = Arrays.copyOf(aeqrOriginalOrder, aeqrOriginalOrder.length); 
    return System.currentTimeMillis() - lStartTime; 
} 


public void sortNativeJava() { 

    System.out.println("\nSorting with native Java Sort"); 
    long lStartTime = System.currentTimeMillis(); 

    Arrays.sort(aeqrCitySort, EarthquakeRecord.CompareCity.instance); 

    long lElapseTime = System.currentTimeMillis() - lStartTime; 
    System.out.println("Native Java Sort: City Name: Elapsed time: " + ((float)  lElapseTime)/1000.0); 

    lStartTime = System.currentTimeMillis(); 

    Arrays.sort(aeqrDepthSort, EarthquakeRecord.CompareDepth.instance); 

    lElapseTime = System.currentTimeMillis() - lStartTime; 
    System.out.println("Native Java Sort: Depth: Elapsed time: " + ((float)  lElapseTime)/1000.0); 

    lStartTime = System.currentTimeMillis(); 

    Arrays.sort(aeqrMagnitudeSort, EarthquakeRecord.CompareMagnitude.instance); 

    lElapseTime = System.currentTimeMillis() - lStartTime; 
    System.out.println("Native Java Sort: Magnitude: Elapsed time: " + ((float)  lElapseTime)/1000.0); 
} 

public void display() { 
    String[] asSortKeys = { "Original", "City Name", "Magnitude", "Depth" }; 
    String sReturnValue = (String) JOptionPane.showInputDialog(null, "Select array to sequence display:", "Key Sequence", JOptionPane.INFORMATION_MESSAGE, null, asSortKeys, asSortKeys[0]); 
    if (sReturnValue == asSortKeys[0]) 
     display("Original Sequence", aeqrOriginalOrder); 
    else if (sReturnValue == asSortKeys[1]) 
     display("City Name Sequence", aeqrCitySort); 
    else if (sReturnValue == asSortKeys[2]) 
     display("Magnitude Sequence", aeqrMagnitudeSort); 
    else 
     display("Depth Sequence", aeqrDepthSort); 
} 


private void display(String rsLabel, EarthquakeRecord[] raeqrDataSet) { 
    if (raeqrDataSet == null) { 
     JOptionPane.showMessageDialog(null, "Error: Selected array not yet populated."); 
     return; 
    } 

    System.out.println(rsLabel); 
    if (nNumRecordsLoaded < 30) 
     for (int i = 0; i < nNumRecordsLoaded; ++i) 
      System.out.println(raeqrDataSet[i]); 
    else { 
     System.out.println("First 10 records:"); 
     for (int i = 0; i < 10; ++i) 
      System.out.println(raeqrDataSet[i]); 

     System.out.println("Middle 10 records:"); 
     int nStart = nNumRecordsLoaded/2 - 5; 
     int nEnd = nStart + 10; 
     for (int i = nStart; i < nEnd; ++i) 
      System.out.println(raeqrDataSet[i]); 

     System.out.println("Last 10 records:"); 
     for (int i = nNumRecordsLoaded - 10; i < nNumRecordsLoaded; ++i) 
      System.out.println(raeqrDataSet[i]); 
    } 
} 


public String toString1() { return "Number of Records: " + nNumRecordsLoaded; } 
private int[] data; 
    private static final Random generator = new Random(); 

    public MergeSort(int size) 
    { 
     data = new int[ size ]; 

     for (int i = 0; i < size; i++) 
     data[ i ] = 10 + generator.nextInt(90); 
    } 

    public void sort() 
    { 
     sortArray(0, data.length - 1); 
    } 
    private void sortArray(int low, int high) 
    { 

     if ((high - low) >= 1) 
     { 
     int middle1 = (low + high)/2; 
     int middle2 = middle1 + 1; 

     System.out.println("split: " + subarray(low, high)); 
     System.out.println("   " + subarray(low, middle1)); 
     System.out.println("   " + subarray(middle2, high)); 
     System.out.println(); 

     sortArray(low, middle1); 
     sortArray(middle2, high); 


     merge (low, middle1, middle2, high); 
     } 
    } 

    private void merge(int left, int middle1, int middle2, int right) 
    { 
     int leftIndex = left; 
     int rightIndex = middle2; 
     int combinedIndex = left; 
     int[] combined = new int[ data.length ]; 

     System.out.println("merge: " + subarray(left, middle1)); 
     System.out.println("   " + subarray(middle2, right)); 

     while (leftIndex <= middle1 && rightIndex <= right) 
     { 
     if (data[ leftIndex ] <= data[ rightIndex ]) 
      combined[ combinedIndex++ ] = data[ leftIndex++ ]; 
     else 
      combined[ combinedIndex++ ] = data[ rightIndex++ ]; 
     } 
     if (leftIndex == middle2) 
     while (rightIndex <= right) 
      combined[ combinedIndex++ ] = data[ rightIndex++ ]; 
     else 
     while (leftIndex <= middle1) 
      combined[ combinedIndex++ ] = data[ leftIndex++ ];  

     for (int i = left; i <= right; i++) 
     data[ i ] = combined[ i ]; 


     System.out.println("   " + subarray(left, right)); 
     System.out.println(); 
    } 

    public String subarray(int low, int high) 
    { 
     StringBuilder temporary = new StringBuilder(); 


     for (int i = 0; i < low; i++) 
     temporary.append(" "); 


     for (int i = low; i <= high; i++) 
     temporary.append(" " + data[ i ]); 

     return temporary.toString(); 
    } 

    public String toString() 
    { 
     return subarray(0, data.length - 1); 
    } 
}

來源

2012-10-08 user1727577

歡迎來到StackOverflow！當在SO上提出問題時，請保留代碼並僅顯示需要的內容，因爲回答這些問題時閱讀和理解整個代碼非常困難。你也會更快得到答案！ –

啊好吧對不起，並感謝您的提示 – user1727577

請幫我理解你的對象在這裏。你究竟是什麼意思「從EarthquakeRecord中對引用進行排序」？你的意思是你想用'EarthquakeRecord []'代替'int []'嗎？如果是的話，你想使用哪種比較方法？ –

當您打開從整數的排序與自定義的比較對象，你必須更換比較

if (data[ leftIndex ] <= data[ rightIndex ])

喜歡的東西

if (cmp.compare(data[ leftIndex ], date[ rightIndex ]) <= 0)

你可能想使用仿製藥，這就意味着你的類將是MergeSort<T>，排序的陣列將是一個T[]（或List<? extends T>）和你比較一個Comparator<? super T>。您可能還會提供一個靜態方法，如Arrays.sort您在sortNativeJava代碼中使用的方法。

來源

2012-10-08 05:42:34 MvG

嘿感謝您的答案，這是我已經嘗試做，但即時通訊一個錯誤 – user1727577

if（EarthquakeRecord.CompareMagnitude.compare（data [leftIndex] <= data [rightIndex] <= 0））; – user1727577

它說的是運算符<=沒有爲參數類型定義地震記錄，地震記錄 – user1727577

有一個程序，我想融合合併排序，但這樣做有困難

回答

相關問題