java - php 的 array_multisort 函数相当于 java 中的函数

Question

我正在寻找相当于 *php's array_multisort* 的内容在Java中。

//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)
}

我怎样才能使用内置的东西实现这个结果，我知道如何使用自定义代码实现它 .

注意*请访问 this link 在回答问题之前解释该函数应该如何工作*

Answer 1

这有点复杂，没有 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]);
    }
  }

似乎有效；)

顺便说一句，如果您需要它用于任意对象类型，只需发表评论。