1

我有一个名为变量的类

Class Variable{ private String name; private int[] domain; //...etc}

它表示特定结构中的变量（约束满足问题）。

我在 ArrayList< 变量 > 中实例化了一组变量并填充了一个整数数组。 

 ArrayList<Variable> vars=new ArrayList<Variable>();
 Variable a=new Variable("A",new int[]{1,2});
 vars.add(a);
 // Define all variables;
 int[] cons=new int[vars.size()];
  for(int i=0;i<cons.length;i++)
    cons[i]=number_of_constraints(vars.get(i));
    // cons contains number of involved constraints for each variable

现在我需要根据约束的数量对它们进行降序排序。

换句话说：给定对象列表 [(A,{1,2}) , (B,{3,4}) , (C,{5,6}) ]和整数数组cons={1,2,0}如何根据整数数组对对象列表进行降序排序？

4

4 回答 4

2

如果您想保持 ClassVariable完整，以下代码将对给定的vars外部进行排序：

   Collections.sort(vars, new Comparator<Variable>() {
       public int compare(Variable var1, Variable var2) {
           return var2.number_of_constraints() - var1.number_of_constraints();
    }});

如果你可以改变 Class Variable，让它实现接口Comparable：

class Variable implements Comparable<Variable> {
    //...

    public int compareTo(Variable other) {
        return this.number_of_constraints() -
               other.number_of_constraints();
    }
}

然后您可以按以下方式排序vars：

Collections.sort(vars);
于 2013-02-23T11:30:36.910 回答
2

使用排序集合，如TreeSet

class Variable {

    private String name;
    private int[] domain;
};
final Set<Variable> variables = new TreeSet<Variable>( new Comparator<Variable>() {

    public int compare(Variable o1, Variable o2) {
        //Do comparison here
        //return -1 if o1 is less than o2
        //1 if o1 is greater than o2
        //0 if they are the same
    }
});

现在你有一个排序Set的Variables。这保证总是被排序。

于 2013-02-23T11:31:46.180 回答
1

您的 Variable 类应该实现Comparable接口，当它实现时，您应该实现compareTo方法。

之后，您可以通过调用Collection.sort方法对其进行排序。

如果您想按排列排序，如果您的索引只是创建一个新ArrayList索引并将每个索引映射到新索引（使用 for 循环）

这是这样一个（通用）方法

public static <T> ArrayList<T> permutate(ArrayList<T> origin,int[] permutation){
        ArrayList<T> result = new ArrayList<T>(permutation.length);
        for(int j=0;j<permutation.length;j++){
            result.add(null);
        }
        for(int i=0;i<permutation.length;i++){
            result.set(i, origin.get(permutation[i]));
        }
        return result;
    }

你可以做myArrayList= permutate(myArrayList, new int{1,2,3});

这是更基本用例（整数）中的示例用法：

public static void main(String... args){
    ArrayList<Integer> origin = new ArrayList<>(4);
    origin.add(1);
    origin.add(2);
    origin.add(3);
    origin.add(4);

    int[] per = new int[]{2,1,3,0};
    origin = permutate(origin,per);
    System.out.println(Arrays.toString(origin.toArray())); //prints [3,2,4,1], your permutation
}
于 2013-02-23T11:27:41.007 回答
1

至于Variablecontains numOfConstraints，根据您的代码，您可以使您的Variable类实现Comparable接口，例如

public class Variuable implements Comparable<Variable> {

    private int numOfConstraints;

    public int compareTo(Variable other){
        if(this == other) { return 0; }
        return (numOfConstraints == other.numOfConstraint) ? 0 : ((numOfConstraints > other.numOfConstraint) ? 1 : -1);
    }

}

然后使用实用方法java.util.Collections.sort(vars);，就是这样。

于 2013-02-23T11:31:58.393 回答