나는 확실하지 않다 하나 개의 행 데이터

Question

에 기초하여 두 차원 배열을 정렬하면 제목은 당연히 물어하려고 무엇을 제안합니다. 이후, 즉 정렬 한 후 동일한 열,에 있어야합니다 2 행의

int[][] x={{1,7,6},{2,4,8}}; 

가 지금은 오름차순으로 첫 번째 행을 정렬 할 데이터 :이 전 아래와 같이 두 가지 차원 INT 배열이 있다고 가정 해 봅시다 정렬, 배열은 다음과 같이해야합니다 :

x={{1,6,7},{2,8,4}} 

을 할 수있는 올바른 방법은 무엇입니까?

Answer 1

이것은 사용자 고유의 정렬 루틴을 구현하여 수행 할 수 있지만 더 나은 방법은 리팩터링을하는 것입니다.

각 쌍을 자체 객체로 묶은 숫자 쌍의 배열로 데이터를 캡슐화하십시오. 그런 다음 첫 번째 값을 정렬하고 두 값 중 하나에 액세스 할 수 있습니다.

class Pair<T extends Comparable<T>> implements Comparable<Pair<T>> { 
    final T a; 
    final T b; 

    public Pair (T a, T b) { 
    this.a = a; 
    this.b = b; 
    } 

    @Override 
    public int compareTo(Pair<T> o) { 
    // Comparison on 'a' only. 
    return a.compareTo(o.a); 
    } 

    @Override 
    public String toString() { 
    return "{" + a + "," + b + "}"; 
    } 
} 

public static void main(String args[]) { 
    Pair[] pairs = { 
    new Pair(1,2), 
    new Pair(7,4), 
    new Pair(6,8), 
    }; 
    System.out.println("Before: "+Arrays.toString(pairs)); 
    Arrays.sort(pairs); 
    System.out.println("After: "+Arrays.toString(pairs)); 
} 

인쇄

Before: [{1,2}, {7,4}, {6,8}] 
After: [{1,2}, {6,8}, {7,4}] 

Answer 2

쉬운 방법은 쌍을 보유하고 Pair 객체를 생성하고, 만 쌍의 첫 번째 항목을 비교하는 사용자 정의 비교기와 함께 쌍의 컬렉션을 정렬하는 것입니다. 필요한 경우

당신은 항상 2 차원 배열에 다시 쌍을 변환 할 수 있습니다. 아마도 가장 효율적인 방법은 아니지만 대부분의 사용 사례에 대한 충분해야

.

Answer 3

은 그것은 자신의 정렬 알고리즘을 구현하고 두 번째 행의 값을 이동하여 수행 할 수 있습니다.

당신은 Obejcts의 배열이있을 수 있습니다. 각 객체는 값을 유지합니다. 그런 다음 사용자 정의 비교기를 구현하고 정렬 함수를 사용하십시오.

나는 한 번 더 생각이 : (당신이 그렇게 할 수있는 경우) 배열 순서를 변경. 그런 다음 하나의 int [] 테이블에 쌍을 유지하십시오. 그리고 외부 테이블은 INT 테이블에 대한 conatiner은 다음과 같습니다

첫 번째 행의 모든 ​​요소가 독특하고 null이 아닌 경우

int [][] a = {{2,5},{1,4},{3,6}}; 
Arrays.sort(a, new Comparator<int[]>() { 
     @Override 
     public int compare(int[] p_o1, int[] p_o2) { 
      return Integer.valueOf(p_o1[0]).compareTo(p_o2[0]); 
     } 
}); 

Answer 4

, 당신은 정렬하기 전에 먼저 행 요소를 가리키는지도를 채울 수 있습니다 자신의 두 번째 행 대응. 첫 번째 행을 정렬 한 후지도를 사용하여 두 번째 행의 첫 번째 (정렬 된) 행의 해당 요소를 조회 할 수 있습니다.

Answer 5

기본적으로 Map을 수행하고 있습니다. Map 구현을 사용하면 도움이됩니다.

TreeMap

그렇게 쉬운 솔루션이 그 안에 모든 매핑 된 값을 배치 할 것, SortedMap을 구현

SortedMap<Integer, Integer> map = new TreeMap<Integer, Integer>(); 
map.put(1, 2); 
map.put(7, 4); 
map.put(6, 8); 

// You can iterate over map now, it'll be already sorted 
for(Map.Entry<Integer, Integer> entry: map.entrySet()) 
{ 
    System.out.println(entry.getKey()+" : "+entry.getValue()); 
} 

// This is not really necessary 
Integer[][] x = {map.keySet().toArray(new Integer[0]), map.values().toArray(new Integer[0])}; 

// If you have Apache Commons you can: 
int[][] y = {ArrayUtils.toPrimitive(map.keySet().toArray(new Integer[0])), ArrayUtils.toPrimitive(map.values().toArray(new Integer[0]))}; 

Answer 6

내가

public static void main(String[] args) throws Exception { 
     int[][] x = { { 1, 7, 6 }, { 2, 4, 8 } }; 
     qsort(x[0], x[1], 0, x[0].length - 1); 
     System.out.println(Arrays.deepToString(x)); 
    } 

    static void qsort(int[] x0, int[] x1, int left, int right) { 
     int index = partition(x0, x1, left, right); 
     if (left < index - 1) 
      qsort(x0, x1, left, index - 1); 
     if (index < right) 
      qsort(x0, x1, index, right); 
    } 

    static int partition(int[] x0, int[] x1, int left, int right) { 
     int i = left, j = right; 
     int tmp; 
     int pivot = x0[(left + right)/2]; 
     while (i <= j) { 
      while (x0[i] < pivot) 
       i++; 
      while (x0[j] > pivot) 
       j--; 
      if (i <= j) { 
       tmp = x0[i]; 
       x0[i] = x0[j]; 
       x0[j] = tmp; 

       // swap x1 too 
       tmp = x1[i]; 
       x1[i] = x1[j]; 
       x1[j] = tmp; 

       i++; 
       j--; 
      } 
     } 
     return i; 
    } 
} 

이 프로그램의 인쇄 http://www.algolist.net/Algorithms/Sorting/Quicksort에서 약간 수정과를 qsort를 붙여 복사

[[1, 6, 7], [2, 8, 4]] 

길게 보일 수 있지만 일반적으로 알고리즘의 효율성이 중요하며이 솔루션이 가장 빠를 것으로 보입니다.