Java 使用第三个数组作为轴心对三个数组进行排序

我有3个数组

a[n]，b[n]，c[n]

a和b数组由用户输入，c计算为

c[i]=b[i]-a[i]+1

对c数组进行排序很容易。我把它分类了

排序（c）方法

现在我必须按照c对数组a和b进行排序，如下所示

比如说-

a[5]={1,3,5,7,9}

b[5]={5,4,7,8,10}

那么c[]将被计算为

c[i]=b[i]-a[i]+1

c[5]={5,2,3,2,2}

现在，对c数组进行排序将导致

c[5]={2,2,2,3,5}

现在我还想要a[I]和b[I]作为

a[5]={3,7,9,5,1}

b[5]={4,8,10,7,5}

这样，现在阵列之间的关系将得到维护 对于每个元素“i”

c[i]=b[i]-a[i]+1

---

此问题有两种解决方案：

创建一个类

AbcHolder

，该类包含与

a[i]

、

b[i]

和

c[i]

相对应的三个元素，使用自定义分类器在

c

字段中对其进行排序，并将

a

s、

b

s和

c

s写回相应的数组，或

制作一个索引数组

idx[]

，用从零到

c.length-1

（含）的数字填充，并对其进行排序，而不是排序

c[]

。使用自定义比较器在相应索引处比较

c

s。之后，您可以对匹配索引重新排序

b

和

a

---

当您对c[5]进行排序时。您可以按值对其进行排序，并将得到对应键值对的数组

它将返回如下数组

array(5) { [1]=> int(2) [3]=> int(2) [4]=> int(2) [2]=> int(3) [0]=> int(5) } 

通过使用上面排序的c[5]数组的键，可以得到a[5]和b[5]的对应值

---

我希望这对你有帮助

使用数组太麻烦了。您可以将它们保存在一个类中：

public class Triplets {
    public int a;
    public int b;
    public int c;
}

然后我们可以在这个类中获取输入，而不是单独的数组（例如）：

当然，比较国：

 public class TripletsComp implements Comparator<Triplets> {
        @Override public int compare(Triplets e1, Triplets e2) {
            if(e1.c > e2.c){
                return 1;
            }else if (e1.c == e2.c){
                return 0;
            }
            else { return -1; }
        }
    }

公共类TripletsComp实现了Comparator{
@覆盖公共整数比较（三元组e1、三元组e2）{
如果（e1.c>e2.c）{
返回1；
}else if（e1.c==e2.c）{
返回0；
}
else{return-1；}
}
}

---

如果您不熟悉Comarator，请阅读它们：）

如果您在不使用任何预定义函数的情况下对它们进行排序，那么您可以进行任何稳定排序，例如插入、合并或气泡排序，并在第二个数组中执行交换时交换第一个数组中的数字。

我找到的最佳方法，在不创建新阵列的情况下，正在使用

交换程序

。允许您在排序在两个索引之间交换时执行其他操作。我使用了it.unimi.dsi.fastutil.array.quickSort（int，int，IntComparator，Swapper），来自。这是我的代码：

public static void main(String[] args) {
    final int SIZE = 25;
    Random rand = new Random();
    int[] a = new int[SIZE];
    int[] b = new int[SIZE];
    int[] c = new int[SIZE];

    for (int i = 0; i < a.length; i++)
        a[i] = rand.nextInt(100);
    for (int i = 0; i < b.length; i++)
        b[i] = rand.nextInt(100);
    for (int i = 0; i < c.length; i++)
        c[i] = b[i] - a[i] + 1;

    Arrays.quickSort(0, SIZE, new AbstractIntComparator() {

        @Override
        public int compare(int k1, int k2) {
            return Integer.compare(c[k1], c[k2]);
        }
    }, new Swapper() {

        @Override
        public void swap(int i, int j) {
            // Swap in c
            int temp = c[i];
            c[i] = c[j];
            c[j] = temp;

            // Swap in a and b
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            temp = b[i];
            b[i] = b[j];
            b[j] = temp;
        }
    });
}

publicstaticvoidmain（字符串[]args）{
最终整数大小=25；
Random rand=新的Random（）；
int[]a=新的int[SIZE]；
int[]b=新的int[SIZE]；
int[]c=新的int[SIZE]；
for（int i=0；i

当我试图编译您的代码时，它给我的错误是QuickComp.java:21:错误：找不到符号数组。quickSort（0，大小，new AbstractIntComparator（）{^symbol:class AbstractIntComparator位置：class QuickComp QuickComp.java:27:错误：找不到符号}，new Swapper（）{^symbol:类交换程序位置：类QuickComp 2错误。很抱歉格式不正确，我是新成员，无法确定如何format@BrijRajKishore可能是因为您导入了

java.util.Arrays

，我使用了

It.unimi.dsi.fastutil.Arrays

。要导入此类，您需要下载库。

 public class TripletsComp implements Comparator<Triplets> {
        @Override public int compare(Triplets e1, Triplets e2) {
            if(e1.c > e2.c){
                return 1;
            }else if (e1.c == e2.c){
                return 0;
            }
            else { return -1; }
        }
    }

public static void main(String[] args) {
    final int SIZE = 25;
    Random rand = new Random();
    int[] a = new int[SIZE];
    int[] b = new int[SIZE];
    int[] c = new int[SIZE];

    for (int i = 0; i < a.length; i++)
        a[i] = rand.nextInt(100);
    for (int i = 0; i < b.length; i++)
        b[i] = rand.nextInt(100);
    for (int i = 0; i < c.length; i++)
        c[i] = b[i] - a[i] + 1;

    Arrays.quickSort(0, SIZE, new AbstractIntComparator() {

        @Override
        public int compare(int k1, int k2) {
            return Integer.compare(c[k1], c[k2]);
        }
    }, new Swapper() {

        @Override
        public void swap(int i, int j) {
            // Swap in c
            int temp = c[i];
            c[i] = c[j];
            c[j] = temp;

            // Swap in a and b
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            temp = b[i];
            b[i] = b[j];
            b[j] = temp;
        }
    });
}