1

私はJavaで*phpのarray_multisort*に相当するものを探していました。

//array 1
ar1 = array(10, 100, 100, 0);
//array 2
ar2 = array(1, 3, 2, 4);
//calling the function
//this will sort the array at first based one the first array and then based on the    
//second array so these two array are related
array_multisort(ar1, ar2);


//resultant 1st array
array(4) {
[0]=> int(0)
[1]=> int(10)
[2]=> int(100)
[3]=> int(100)  
}

//resultant 2nd array
//this array has been sorted based on the first array at first

array(4) {
[0]=> int(4) // this is associative element of 0 in the first array 
[1]=> int(1) //this is associative element of 10 in the first array 
[2]=> int(2) //this is associative element of  1st 100 from the last in the first array 
             //as there are two 100's , and last one's associative value in the second
             //array is smaller it will come first   
[3]=> int(3)
}

組み込みのものを使用してこの結果を達成するにはどうすればよいですか、カスタムコードを使用して実装する方法を知っています。

NB *訪問してくださいこのリンク関数がどのように機能するかを説明する質問に答える前に*

4

5 に答える 5

4

これはもう少し複雑で、Java 標準 API なしでは実行できません。そこで、クイックソートの実装を再利用して、複数の配列で機能するようにしました。基本的にクイックソートのパーティショニングで要素が入れ替わる場合は、要素を入れ替えます。

どうぞ：

 /**
   * Multi-sorts the given arrays with the quicksort algorithm. It assumes that
   * all arrays have the same sizes and it sorts on the first dimension of these
   * arrays. If the given arrays are null or empty, it will do nothing, if just
   * a single array was passed it will sort it via {@link Arrays} sort;
   */
  public static void multiQuickSort(int[]... arrays) {
    multiQuickSort(0, arrays);
  }

  /**
   * Multi-sorts the given arrays with the quicksort algorithm. It assumes that
   * all arrays have the same sizes and it sorts on the given dimension index
   * (starts with 0) of these arrays. If the given arrays are null or empty, it
   * will do nothing, if just a single array was passed it will sort it via
   * {@link Arrays} sort;
   */
  public static void multiQuickSort(int sortDimension, int[]... arrays) {
    // check if the lengths are equal, break if everything is empty
    if (arrays == null || arrays.length == 0) {
      return;
    }
    // if the array only has a single dimension, sort it and return
    if (arrays.length == 1) {
      Arrays.sort(arrays[0]);
      return;
    }
    // also return if the sort dimension is not in our array range
    if (sortDimension < 0 || sortDimension >= arrays.length) {
      return;
    }
    // check sizes
    int firstArrayLength = arrays[0].length;
    for (int i = 1; i < arrays.length; i++) {
      if (arrays[i] == null || firstArrayLength != arrays[i].length)
        return;
    }

    multiQuickSort(arrays, 0, firstArrayLength, sortDimension);
  }

  /**
   * Internal multi quicksort, doing the real algorithm.
   */
  private static void multiQuickSort(int[][] a, int offset, int length,
      int indexToSort) {
    if (offset < length) {
      int pivot = multiPartition(a, offset, length, indexToSort);
      multiQuickSort(a, offset, pivot, indexToSort);
      multiQuickSort(a, pivot + 1, length, indexToSort);
    }
  }

  /**
   * Partitions the given array in-place and uses the end element as pivot,
   * everything less than the pivot will be placed left and everything greater
   * will be placed right of the pivot. It returns the index of the pivot
   * element after partitioning. This is a multi way partitioning algorithm, you
   * have to provide a partition array index to know which is the array that
   * needs to be partitioned. The swap operations are applied on the other
   * elements as well.
   */
  private static int multiPartition(int[][] array, int start, int end,
      int partitionArrayIndex) {
    final int ending = end - 1;
    final int x = array[partitionArrayIndex][ending];
    int i = start - 1;
    for (int j = start; j < ending; j++) {
      if (array[partitionArrayIndex][j] <= x) {
        i++;
        for (int arrayIndex = 0; arrayIndex < array.length; arrayIndex++) {
          swap(array[arrayIndex], i, j);
        }
      }
    }
    i++;
    for (int arrayIndex = 0; arrayIndex < array.length; arrayIndex++) {
      swap(array[arrayIndex], i, ending);
    }

    return i;
  }
 /**
   * Swaps the given indices x with y in the array.
   */
  public static void swap(int[] array, int x, int y) {
    int tmpIndex = array[x];
    array[x] = array[y];
    array[y] = tmpIndex;
  }

質問からの入力をテストするために、小さなテストケースを実行します。

@Test
  public void testMultiQuickSort() {
    int[] first = new int[] { 10, 100, 100, 0 };
    int[] second = new int[] { 1, 3, 2, 4 };
    int[] resFirst = new int[] { 0, 10, 100, 100 };
    int[] resSecond = new int[] { 4, 1, 2, 3 };

    ArrayUtils.multiQuickSort(first, second);

    for (int i = 0; i < first.length; i++) {
      assertEquals(resFirst[i], first[i]);
      assertEquals(resSecond[i], second[i]);
    }
  }

うまくいくようです;）

ところで、任意のオブジェクト タイプに必要な場合は、コメントを残してください。

于 2012-08-27T13:31:23.610 に答える
2

多次元配列は単なる配列の配列であるため、個々の配列を反復処理して並べ替えます。

int[][] marr = // your multi-dimensional array here
for (int[] arr : marr) {
    Arrays.sort(arr);
}

そして、何らかの理由で、最初の配列を 2 番目の次元でのみ並べ替えたい場合は、次のようにします。

Arrays.sort(marr[0]);

ああ、今私はあなたが何を望んでいるのか理解しています。要素 (少なくとも最初の配列の要素) が一意である場合は、SortedMap を介してそれを行うことができます。

if(arr1.length!=arr2.length)throw new IllegalArgumentException();
SortedMap<Integer,Integer> map = new TreeMap<Integer, Integer>();
for (int i = 0; i < arr1.length; i++) {
    map.put(arr1[i],arr2[i]);
}
int ct = 0;
for (Entry<Integer, Integer> entry : map.entrySet()) {
    arr1[ct]=entry.getKey();arr2[ct]=entry.getValue();
    ct++;
}
于 2012-08-27T11:55:35.073 に答える
0

Java には、この目的のための組み込みライブラリ関数/クラスがないようです。私のようにこの問題にも直面している場合は、これまでのところ、カスタムコードに関するトーマスの回答が役立ちます。

于 2012-09-06T15:09:58.433 に答える
-1

Comparator を実装するか、アルゴリズム バブル ソートを使用する

Arrays.sort(stringArray); it will sort only one array
于 2012-08-27T11:13:12.240 に答える
-3

たぶん、次のコードが役に立ちます。

使用する必要がありますArrays.sort()

例：

import java.util.Arrays;

String [] stringArray = {"ab", "aB", "c", "0", "2", "1Ad", "a10"};

//order Ascending
Arrays.sort(stringArray);

//Descending
Arrays.sort(stringArray, Collections.reverseOrder());
于 2012-08-27T11:28:04.007 に答える