关于数组比较的算法

数组A 中存放等级信息

数组B 中存放高度信息

数组C 中存放变化量信息

A、B、C中的信息都是一一对应的，数量都是相等的。

最大等级是已知的为3

现在比较这三个数组，按如下规则取出唯一一对记录（等级、高度、变化量）。

等级比较 ---> 高度比较 ---> 变化量比较

具体如下：

首先取出等级A 中等级最大的的几对记录 ABC_1，

然后在等级最大记录ABC_1中比较高度，取出高度最大的几对记录ABC_2，

然后在高度最大记录ABC_2中比较变化量，最后取出变化量最大的几对记录 ABC_3。

当然了，如果以上三次比较中，任何一次结果为1条数据的话，就不用继续比较了。

不知道各位有什么好的算法建议。

看这个吧，我测试过了，是按我上面理解的意思。最上面的程序少了两句话。

import java.util.*;
public class ArrayCompare{
private ArrayList index = new ArrayList();
private ArrayList _index = new ArrayList();

public ArrayList<Integer> compare(int [] a,int [] b,int [] c){

    for(int i =0;i<a.length;i++){
        _index.add(i);
    }
    check(a);
    if(index.size() == 1)
        return index;
    check(b);
    if(index.size() == 1)
        return index;
    check(c);   
    return index;
}

public void check(int [] x){
    index.clear();
    int max = x[((Integer)_index.get(0)).intValue()];
    for(Integer i : _index){
        int ii = i.intValue();
        if(x[ii]>max){
            max=x[ii];
            index.clear();  
        }
        if(x[ii] == max)
            index.add(ii);
    }   
    _index.clear();
    _index.addAll(index);   
}

public static void main(String [] args)throws Exception{
    ArrayCompare ac = new ArrayCompare();
    int []a = new int[]{0,2,3,3,2,3,1};
    int []b = new int[]{2,3,7,6,4,7,8};
    int []c = new int[]{2,3,4,2,1,0,3};
    ArrayList<Integer> aa = ac.compare(a,b,c); 
    for(Integer i : aa){
        int ii = i.intValue();
        System.out.println(a[ii]);
        System.out.println(b[ii]);
        System.out.println(c[ii]);
    }   
}

}

简单实现了一下，等待高手

class ArrayCompare{
private ArrayList index = new ArrayList();
private ArrayList _index = new ArrayList();

public ArrayList<Integer> compare(int [] a,int [] b,int [] c){

    for(int i =0;i<a.length;i++){
        _index.add(i);
    }

    check(a);
    if(index.size() == 1)
        return index;
    check(b);
    if(index.size() == 1)
        return index;
    check(c);
            return index;
}

public void check(int [] x){
    int max = x[index.get(0)];
    for(int i : _index){
        if(x[i]>max){
            max=x[i];
            index.clear();  
        }
        if(x[i] == max)
            index.add(i);
    }
    _index.addAll(index);
}

}

第一个方法的第一个循环里漏了一句index.add(i);

或者把第二个方法的第一句的index换成_index
不好意思，我也没测试，回答2和3任选一个，应该没问题了。

对了，有些类型没做转换

package com;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
/**

结构类，包含你所说的数组 A B C 以及专门保存最大值下标的List列表maxIndex
@author 蒲佳BOSS
*
*/
class ABC {
private List maxIndex = new ArrayList();
private int[] A;
private int[] B;
private int[] C;
/**
构造一个结构，并执行查找find方法
@param a
@param b
@param c
/
public ABC(int a[], int b[], int c[]) {
this.A = a;
this.B = b;
this.C = c;
find();
}
/*
私有的find方法：通过一个内部类Tmp来定制index-value对，算法是：
A B C数组比较优先级是A>B>C,所以我们可以这样，A*100+B*10+C就把大小完全体现出来了，通过排序Tmp，

得到最大的值列表
*
/
private void find() {
/*
* 内部类
* @author 蒲佳BOSS
*
*/
class Tmp {
public int value;

    public int index;

    public Tmp(int v, int i) {
        value = v;
        index = i;
    }

    public String toString() {
        return "Index=" + index + "   Value=" + value;
    }
}

  //将所有数组合并为一个List<Tmp>

List<Tmp> list = new ArrayList<Tmp>();
for (int i = 0; i < this.A.length; i++) {
    Tmp t = new Tmp(this.A[i] * 100 + this.B[i] * 10 + this.C[i], i);
    list.add(t);
}
//排序list,通过比较器
Collections.sort(list, new Comparator<Tmp>() {

    public int compare(Tmp o1, Tmp o2) {
        if (o1.value < o2.value)
            return 1;
        return 0;
    }

});
//将前面最大值的index的添加到maxIndex
int tmp = list.get(0).value;
maxIndex.add(list.get(0).index);
for (int i = 1; i < list.size(); i++)
    if (list.get(i).value < tmp)
        break;
    else
        maxIndex.add(list.get(i).index);

}

public List getMaxIndex() {
return this.maxIndex;
}

public void showMax() {
for (int i : maxIndex) {
System.out.println("MAX: index=" + i + " A=" + this.A[i]
+ " B=" + this.B[i] + " C=" + this.C[i]);
}
}

}

public class Test {
public static void main(String[] st) {

    int[] a = { 4, 5, 6, 7, 8, 3, 4, 5 };
    int[] b = { 4, 7, 6, 2, 4, 6, 7, 8 };
    int[] c = { 5, 4, 3, 5, 6, 7, 4, 5 };
    ABC abc = new ABC(a, b, c);
    abc.showMax();
}

}
/*

A B C 3 4 2 3 5 1 */

简易版本

package com;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**

结构类，get/set
@author 蒲佳BOSS
*
*/
class ABCTest {
private int a;
private int b;
private int c;
private int index;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
public int getC() {
return c;
}
public void setC(int c) {
this.c = c;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String toString(){
return "index="+index+" A="+a+" B="+b+" C="+c+"\n";
}
}
/**
其实算法很简单，比较器了比较就Ok了。
A B C
5 5 6
6 5 3
4 6 9
8 1 0
8 0 0
7 2 9
你还没发现其实就是个1000以内的整数比较吗
@author 蒲佳BOSS
*
*/
public class Main{
public static void main(String[] str){
List list=new ArrayList();
int[] a = { 4, 5, 6, 7, 8, 3, 4, 5 };
int[] b = { 4, 7, 6, 2, 4, 6, 7, 8 };
int[] c = { 5, 4, 3, 5, 6, 7, 4, 5 };
for(int i=0;i ABCTest t=new ABCTest();
t.setA(a[i]);
t.setB(b[i]);
t.setC(c[i]);
t.setIndex(i);
list.add(t);
}
Collections.sort(list, new Comparator() {
```
    public int compare(ABCTest o1, ABCTest o2) {
        if (o1.getA()*100+o1.getB()*10+o1.getC() < o2.getA()*100+o2.getB()*10+o2.getC())
            return 1;
        return 0;
    }

});
System.out.println(list);
```
}

}

如果你的 B C值是超过10的，那么请使用
o2.getA()*100000+o2.getB()*1000+o2.getC()*1
反正乘以你数组中最大的一个值；
比如：
A - B - C
2 567 345
1 999(max) 546
3 0 876(max)

A*(999*876)+B*876+C 比较器

看来我对题目理解有误？

a[0,2,3,3,2,3,1]
b[2,3,7,6,4,7,8]
c[2,3,4,2,1,0,3]

这个结果是3，7，4么？如果不是，那我就理解错了