Итерация над наборами чисел

Question

У меня 3 различных наборов чисел, например
а = {1,3,4}
Ь = {2,6}
с = {0}

размер наборов может быть переменным, например один комплект из 5 элементов, другие с 3 и т.д.

Я сохранил эти значения в HashMap в Java,

HashMap H=new HashMap<String,HashSet<Integer>>(); 

для этого примера, ключи Н «а», «б» , и "c".

Я хочу, чтобы все возможные комбинации чисел в этих трех наборов, то есть:
1,2,0
1,6,0
3,2,0
3,6,0
4,2,0
4,6,0

Но у меня есть проблема. Количество наборов также может быть переменным, т. Е. Мой HashMap может иметь от 3 до 10 ключей. Вы знаете, как я должен перебирать хэш-карту, чтобы я мог делать все возможные комбинации?

ОТВЕТ: Я изменил HashMap на Vector, однако, он также работает с HashMap с небольшими изменениями

вызовите функцию следующим образом:

Iterate_over_map(0,new Integer[h.size()],h,final_list); 


Iterate_over_map(int count,Integer[] curr,Vector<HashSet<Integer>> h,Vector<Integer[]> final_list) 
{ 
    if(count>=h.size()) 
    { 
     final_list.addElement(curr.clone()); 
     return; 
    } 

    int next_count=count+1; 
    for (Integer element:h.elementAt(count)) 
    { 

     curr[count]=element; 
     Iterate_over_map(next_count,curr,h,final_list); 
    } 

} 

OLD раствора

for(int x:H.get("a")) 
{ 
    v[0]=x;//node1 (an ortholog of node1) 
    for(int y:H.get("b")) 
    { 
     v[1]=y;//node2 (an ortholog of node2) 
     for(int z:H.get("c")) 
     { 
      v[2]=z;//node3 (an ortholog of node3) 
     } 
    } 
} 

большое спасибо.

Answer 1

Вам нужно использовать рекурсию вместо ваших вложенных циклов, то это будет делать то, что вы хотите:

public static void main(String[] args) 
{ 
    List<List<Integer>> integers = new ArrayList<List<Integer>>(); 
    integers.add(Arrays.asList(1, 3, 4)); 
    integers.add(Arrays.asList(2, 6)); 
    integers.add(Arrays.asList(0)); 

    List<List<Integer>> combinations = combine(integers); 

    System.out.println(combinations); 
} 

private static List<List<Integer>> combine(List<List<Integer>> allIntegers) 
{ 
    List<Integer> integers = allIntegers.remove(0); 
    List<List<Integer>> allCombinations = new ArrayList<List<Integer>>(); 

    for (Integer i : integers) 
    { 
    if (allIntegers.isEmpty()) 
    { 
     allCombinations.add(new ArrayList<Integer>(Arrays.asList(i))); 
    } 
    else 
    { 
     for (List<Integer> combinations : combine(new ArrayList<List<Integer>>(allIntegers))) 
     { 
     combinations.add(0, i); 
     allCombinations.add(combinations); 
     } 
    } 
    } 

    return allCombinations; 
} 

Который выводит:

[[1, 2, 0], [1, 6, 0], [3, 2, 0], [3, 6, 0], [4, 2, 0], [4, 6, 0]] 

Answer 2

Вы должны использовать рекурсивную функцию. Я делаю пример

public static void main(String[] args) { 
    String[] keys = map.keySet().toArray(new String[0]); 
    loopMap(map, keys, 0, ""); 
} 

public static void loopMap(Map<String, Set<Integer>> map, String[] keys, int index, String res) { 
    if (index == keys.length) { 
     System.out.println(res); 
     return; 
    } 
    Set<Integer> set = map.get(keys[index]); 

    for(Integer ele : set) { 
     loopMap(map, keys, index + 1, res + ele); 
    } 
} 

С: карта использования LinkedHashMap, установите это LinkedHashSet и проверить нуль ^^