我如何对 2 个并行数组进行排序

Question

我有 2 个数组，1 个 1 维数组和另一个 2 维数组，我必须对其进行排序。问题是我不知道如何对它们进行并行排序。我已经按照字母顺序对 1d 数组进行了排序，但我想相应地对 2d 数组进行排序。所以我需要将这两个数组发送到一个排序函数，该函数将返回两个按升序排序的数组，而一维数组“arr1”中的元素将它们对应的元素保留在二维数组“arr2”中。

到目前为止我所拥有的：

import java.io.*;
import java.util.Scanner;
import java.util.Arrays;

public class JAVAhw15 {
public static void main(String args[]) throws IOException {

//required for input    
BufferedReader usrInput = new BufferedReader(
new InputStreamReader(System.in));

Scanner user_input = new Scanner( System.in );

int row = 10;
int col = 3;
int size = 10;

//Declare & Initialize
int arr2[][] = new int[row][];
String arr1[] = new String[size];

//construct 2d arr
for(int i=0; i<row; i++)
{
    arr2[i] = new int[col];
}

//Filling 1d array arr1
System.out.println("Enter 10 names please: ");
for(int i=0; i<size; i++)
{
    arr1[i] = user_input.next();
}


//Filling 2d array arr2
System.out.println("Enter 3 telephone numbers for each name entered");
for(int i=0; i<row; i++)
{
    for(int j=0; j<col; j++)
    {
        System.out.println(arr1[i]+"'s Tel "+j+" is: ");
        arr2[i][j] = Integer.parseInt(usrInput.readLine());
    }
}

System.out.println("After sort :");

    String merged[] = new String[arr1.length];
    for (int i=0; i< arr1.length; i++) {
        merged[i] = arr1[i]+"=="+arr2[i];
    }
    Arrays.sort(merged);
    for(int i = 0; i < merged.length; i++) {
    System.out.println( (i+1) + ". "+
    merged[i].split("==")[0] + "\t\t" +   
    merged[i].split("==")[1]);
    }
}
}

Answer 1

我可以看到两种解决方案：

• 您创建了一个类，用于合并您存储在两个单独列表中的数据。这样一来，您将只有一个列表，您可以更轻松地为所欲为。

• 您为自己编写了一个类似于快速排序的经典排序，但有一个小的变体：您不仅会对数组进行排序，还会返回一个表示应用于数组以对其进行排序的排列的对象。然后，您只需要编写一个方法来将排列应用于另一个数组。

我更喜欢第一个解决方案，但由于您对第二个解决方案表现出兴趣，这里有一个示例说明您如何做到这一点：

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    private static Random   rd = new Random();

    public static <T extends Comparable<T>> Integer[] sort(T[] arr) {
        Integer[] perm = new Integer[arr.length];
        for (int i=0 ; i<perm.length ; i++)
            perm[i] = i;
        sort(arr,perm,0,arr.length - 1);
        return perm;
    }

    private static <T extends Comparable<T>> void sort(T[] arr, Integer[] perm, int start, int end) {
        if (start < end) {
            int index = pivot(arr,perm,start,end);
            sort(arr,perm,start,index - 1);
            sort(arr,perm,index + 1,end);
        }
    }

    private static <T extends Comparable<T>> int pivot(T[] arr, Integer[] perm, int start, int end) {
        int index  = start + rd.nextInt(end - start + 1);
        T   pivot  = arr[index];
        int result = start;
        swap(arr,perm,index,end);

        for (int i=start ; i<end ; i++) 
            if (arr[i].compareTo(pivot) < 0) 
                swap(arr,perm,i,result++);
        swap(arr,perm,result,end);
        return result;
    }

    private static <T> void swap(T[] arr, Integer[] perm, int i, int j) {
        swap(arr,i,j);
        swap(perm,i,j);
    }

    private static <T> void swap(T[] arr, int i, int j) {
        T tmp  = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;       
    }

    public static void main(String[] args) {
        Integer[] arr = { 1,3,4,6,9,2,8 };
        Integer[] res = sort(arr);
        System.out.println("sorted array : " + Arrays.toString(arr) + ", permutation : " + Arrays.toString(res));
     }
}