排序二維數組，數字應該是連續

Question

我做了一個二維數組，它看起來像這樣和現在一樣：

(3,0) 
(0,1) 
(3,1) 
(0,2) 
(3,2) 
(0,3) 
(1,3) 
(2,3) 
(3,3) 

的問題是，我想知道如何將一個二維數組排序，以便它將會得到如下結果：

(0,0) 
(0,1) 
(0,2) 
(0,3) 
(1,3) 
(2,3) 
(3,3) 
(3,2) 
(3,1) 
(3,0) 

其中每個座標在座標之前或之後至少有一個相同的數字。

編輯：

我想短信息道歉。無論如何，我通過@khaled_gomaa嘗試了代碼，但沒有提供我想要的輸出，但我很感謝他的幫助！

import java.util.Arrays; import java.util.Comparator;

public class Asdf { 

    public static void main(final String[] args) { 
     final int[][] data = new int[][] { new int[] { 0, 0 }, 
       new int[] { 3, 0 }, new int[] { 0, 1 }, new int[] { 3, 1 }, 
       new int[] { 0, 2 }, new int[] { 3, 2 }, new int[] { 0, 3 }, 
       new int[] { 1, 3 }, new int[] { 2, 3 }, new int[] { 3, 3 } }; 

     for (int[] indiv : data) { 
      System.out.println("(" + indiv[0] + "," + indiv[1] + ")"); 
     } 

     Arrays.sort(data, new Comparator<int[]>() { 
      @Override 
      public int compare(final int[] entry1, final int[] entry2) { 
       if (entry1[0] == entry2[0]) { 
        if (entry1[1] > entry2[1]) { 
         return 1; 
        } else { 
         return -1; 
        } 
       } else { 
        if (entry1[0] > entry2[0]) { 
         return 1; 
        } else { 
         return -1; 
        } 
       } 
      } 
     }); 

     System.out.println(); 

     for (int i = 0; i < data.length; i++) { 
      int indiv[] = data[i]; 
      System.out.println("(" + indiv[0] + "," + indiv[1] + ")"); 
     } 
    } 
} 

輸出：

(0,0) 
(0,1) 
(0,2) 
(0,3) 
(1,3) 
(2,3) 
(3,0) 
(3,1) 
(3,2) 
(3,3) 

Answer 1

import java.util.Arrays; 
import java.util.Comparator; 

public class Asdf { 

    public static void main(final String[] args) { 
    final int[][] data = new int[][]{ 
    new int[] {3,0}, 
    new int[] {0,1}, 
    new int[] {3,1}, 
    new int[] {0,2}, 
    new int[] {3,2}, 
    new int[] {0,3}, 
    new int[] {1,3}, 
    new int[] {2,3}, 
    new int[] {3,3} 
    }; 

    Arrays.sort(data, new Comparator<int[]>() { 
     @Override 
     public int compare(final int[] entry1, final int[] entry2) { 
      if(entery1[0] == entry2[0]){ 
       if(entery1[1] > entery2[1]) 
       return 1; 
       else 
       return -1; 
      } 
      else{ 
       if(entery1[0] > entery2[0]) 
       return 1; 
       else 
       return -1; 
      } 

      final String time2 = entry2[0]; 
      return time1.compareTo(time2); 
     } 
    }); 
} 

}

Answer 2

爲什麼不把2一維數組，然後....比較每個單獨？

之後，你應該把它們放在一起，創建一個2d陣列。

我在說這個，因爲它似乎是你個別比較「列」。我的意思是說，你沒有把每個索引中的座標放在一起。無論如何，來自每列的數據都是分開的。

Answer 3

這可以按照您的意願進行分類。

它使用一個名爲TwoIntsForCompare的類，它實現了Comparable。它將指數零值（我稱之爲「主要」）的權重比「次要」（索引1）值大十倍。

class TwoIntsForCompare implements Comparable<TwoIntsForCompare> { 
    public final int major; 
    public final int minor; 
    public TwoIntsForCompare(int[] idx0Major_idx1Minor) { 
     this.major = idx0Major_idx1Minor[0]; 
     this.minor = idx0Major_idx1Minor[1]; 
    } 
    public int compareTo(TwoIntsForCompare to_compareTo) { 
     return (((major - to_compareTo.major) * 10) + 
     (minor - to_compareTo.minor)); 
    } 
    public int[] getArray() { 
     return (new int[] {major, minor}); 
    } 
} 

將每個子陣列到此對象之後，將它們插入到帶有TreeMap確實自動排序，通過使用TwoIntsForCompare小號compareTo功能。

主要邏輯：

Map<TwoIntsForCompare,Object> twoIntsMap = new TreeMap<TwoIntsForCompare,Object>(); 
for(int i = 0; i < intArrArrOrig.length; i++) { 
    twoIntsMap.put(new TwoIntsForCompare(intArrArrOrig[i]), null); 
} 

int[][] intArrArrSorted = new int[intArrArrOrig.length][2]; 
Set<TwoIntsForCompare> tifcSet = twoIntsMap.keySet(); 
int idx = 0; 
Iterator<TwoIntsForCompare> itrTifc = tifcSet.iterator(); 
while(itrTifc.hasNext()) { 
    intArrArrSorted[idx++] = itrTifc.next().getArray(); 
} 

全碼：

import java.util.Set; 
import java.util.Iterator; 
import java.util.TreeMap; 
import java.util.Map; 
/** 
    <P>{@code java SortArrayOfTwoInts}</P> 
**/ 
public class SortArrayOfTwoInts { 
    public static final void main(String[] ignored) { 
     int[][] intArrArrOrig = new int[][] { 
     new int[] {3,0}, 
     new int[] {0,1}, 
     new int[] {3,1}, 
     new int[] {0,2}, 
     new int[] {3,2}, 
     new int[] {0,3}, 
     new int[] {1,3}, 
     new int[] {2,3}, 
     new int[] {3,3}}; 

     System.out.println("Original:"); 
     for(int i = 0; i < intArrArrOrig.length; i++) { 
     System.out.println("[" + intArrArrOrig[i][0] + ", " + intArrArrOrig[i][3] + "]"); 
     } 

     System.out.println(); 

     Map<TwoIntsForCompare,Object> twoIntsMap = new TreeMap<TwoIntsForCompare,Object>(); 
     for(int i = 0; i < intArrArrOrig.length; i++) { 
     twoIntsMap.put(new TwoIntsForCompare(intArrArrOrig[i]), null); 
     } 

     int[][] intArrArrSorted = new int[intArrArrOrig.length][2]; 
     Set<TwoIntsForCompare> tifcSet = twoIntsMap.keySet(); 
     int idx = 0; 
     Iterator<TwoIntsForCompare> itrTifc = tifcSet.iterator(); 
     while(itrTifc.hasNext()) { 
     intArrArrSorted[idx++] = itrTifc.next().getArray(); 
     } 

     System.out.println("Sorted:"); 
     for(int i = 0; i < intArrArrSorted.length; i++) { 
     System.out.println("[" + intArrArrSorted[i][0] + ", " + intArrArrSorted[i][4] + "]"); 
     } 
    } 
} 
class TwoIntsForCompare implements Comparable<TwoIntsForCompare> { 
    public final int major; 
    public final int minor; 
    public TwoIntsForCompare(int[] idx0Major_idx1Minor) { 
     this.major = idx0Major_idx1Minor[0]; 
     this.minor = idx0Major_idx1Minor[1]; 
    } 
    public int compareTo(TwoIntsForCompare to_compareTo) { 
     return (((major - to_compareTo.major) * 10) + 
     (minor - to_compareTo.minor)); 
    } 
    public int[] getArray() { 
     return (new int[] {major, minor}); 
    } 
} 

輸出：

[C:\java_code\]java SortArrayOfTwoInts 
Original: 
[3, 0] 
[0, 1] 
[3, 1] 
[0, 2] 
[3, 2] 
[0, 3] 
[1, 3] 
[2, 3] 
[3, 3] 

Sorted: 
[0, 1] 
[0, 2] 
[0, 3] 
[1, 3] 
[2, 3] 
[3, 0] 
[3, 1] 
[3, 2] 
[3, 3]