如何基於整數

的數組來順序設置對象的我稱變量如何基於整數

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

其表示在特定結構（約束滿足問題）變量的類。

我已經在ArrayList < Variable>中實例化了一組變量，並填充了一個整數數組。

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}如何對基於整數數組遞減的對象列表進行排序？

來源

2013-02-23 seteropere

尼斯代表[academia.se]，順便說一句 – 2013-02-23 11:23:17

什麼是排序標準？ – 2013-02-23 11:26:38

預期產量是多少？ [（B，{3,4}），（C，{5,6}），（A，{1,2}）]'（'cons'是列表中的索引排列）？ – 2013-02-23 11:26:52

使用分類收集像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 
    } 
});

現在你有一個排序的Variable S的Set。這是保證總是排序。

來源

2013-02-23 11:31:46

「這是實施爲紅黑色」請刪除此部分，否 - 在規範中說，TreeSet是使用紅黑樹實施的，即使它在實踐中也不能保證它會在任何有效的Java實現上。唯一的保證是add/remove/contains是log（n）。有很多樹結構可以做到這一點（AVL樹也可以做log（n）add/remove/contains） – 2013-02-23 14:59:33

您的變量類應該實現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-23 11:27:41

如果你想保持Variable類完好，下面的代碼將排序給出vars外：

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

如果你可以改變Variable類，讓它實現接口Comparable：

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

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

Then you can sort vars通過：

Collections.sort(vars);

來源

2013-02-23 11:30:36

至於一個Variable包含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-23 11:31:58 skuntsel

如何基於整數

回答

相關問題