C中多个数组的笛卡尔积

import java.util.*;    

class CartesianIterator <T> implements Iterator <List <T>> {

        private final List <List <T>> lilio;    
        private int current = 0;
        private final long last;

        public CartesianIterator (final List <List <T>> llo) {
                lilio = llo;
                long product = 1L;
                for (List <T> lio: lilio)
                        product *= lio.size ();
                last = product;
        } 

        public boolean hasNext () {
                return current != last;
        }

        public List <T> next () {
                ++current;
                return get (current - 1,lilio);
        }

        public void remove () {
                ++current;
        }

        private List<T> get (final int n,final List <List <T>> lili) {
                switch (lili.size ())
                {
                        case 0: return new ArrayList <T> (); // no break past return;
                        default: {
                                List <T> inner = lili.get (0);
                                List <T> lo = new ArrayList <T> ();
                                lo.add (inner.get (n % inner.size ()));
                                lo.addAll (get (n / inner.size (),lili.subList (1,lili.size ())));
                                return lo;
                        }
                }
        }
}

class CartesianIterable <T> implements Iterable <List <T>> {

        private List <List <T>> lilio;  

        public CartesianIterable (List <List <T>> llo) {
                lilio = llo;
        }

        public Iterator <List <T>> iterator () {
                return new CartesianIterator <T> (lilio);
        }
}

class CartesianIteratorTest {

        public static void main (String[] args) {
                List <Character> la = Arrays.asList (new Character [] {'a','b'});
                List <Character> lb = Arrays.asList (new Character [] {'b','c'});      
                List <Character> lc = Arrays.asList (new Character [] {'c','a'});
                List <List <Character>> llc = new ArrayList <List <Character>> ();
                llc.add (la);
                llc.add (lb);
                llc.add (lc);

                CartesianIterable <Character> ci = new CartesianIterable <Character> (llc);
                for (List<Character> lo: ci)
                        show (lo);

                la = Arrays.asList (new Character [] {'x','y','z'});
                lb = Arrays.asList (new Character [] {'b'});    
                lc = Arrays.asList (new Character [] {'c'});
                llc = new ArrayList <List <Character>> ();
                llc.add (la);
                llc.add (lb);
                llc.add (lc);

                ci = new CartesianIterable <Character> (llc);
                for (List<Character> lo: ci)
                        show (lo);
        }

        public static void show (List <Character> lo) {
                System.out.print ("(");
                for (Object o: lo)
                        System.out.print (o);
                System.out.println (")");
        }
}

我不知道C中是否存在与迭代器类似的东西.迭代很可能对你没用.

代码的想法是,有一个计数器,它在结果集的所有元素上创建一个索引,并计算绑定到该值的元素.

如果我们有3组(1,2,3)(4,5)(6,7,8),我们有18 = 3x2x3的结果.我们可以,例如迭代器位置7计算结果如下：

7 % 3 = 1 => (1,3)[1] = 2 (number modulo 1st group size) 
7 / 3 = 2 (int division)  (number div 1st group size)
2 % 2 = 0 => (4,5)[0] = 4 (rest modulo 2nd group size) 
2 / 2 = 0 
0 % 3 = 0 => (7,8,9) => 7 

idx g1  g2  g3
 0  1   4   6   
 1  2   4   6   
 2  3   4   6   
 3  1   5   6   
 4  2   5   6   
 5  3   5   6   
 6  1   4   7   
 7  2   4   7   
 8  3   4   7   
 9  1   5   7   
10  2   5   7   
11  3   5   7   
12  1   4   8   
13  2   4   8   
14  3   4   8   
15  1   5   8   
16  2   5   8   
17  3   5   8