Question

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

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

您创建了一个类，它将您存储的数据合并到两个单独的列表中。这样，您将只有一个列表，您可以更轻松地按照自己的意愿行事。
你自己写了一个类似于快速排序的经典类型，有一个小变体：你不仅会对aray进行排序，还会返回一个对象，该对象代表应用于数组的排列以对其进行排序。然后，您只需编写一个方法将排列应用于另一个数组。

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

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

我如何排序2个并行数组

1 个答案: