BlogJava-Adley-随笔分类-数学原理http://www.blogjava.net/Adley/category/50391.html机器，宇宙，编程泛型，JdonMVC(framework)zh-cnSat, 17 Dec 2011 09:25:41 GMTSat, 17 Dec 2011 09:25:41 GMT60用OO写笛卡尔积http://www.blogjava.net/Adley/archive/2011/09/26/359543.htmlAdleyAdleyMon, 26 Sep 2011 08:02:00 GMThttp://www.blogjava.net/Adley/archive/2011/09/26/359543.htmlhttp://www.blogjava.net/Adley/comments/359543.htmlhttp://www.blogjava.net/Adley/archive/2011/09/26/359543.html#Feedback1http://www.blogjava.net/Adley/comments/commentRss/359543.htmlhttp://www.blogjava.net/Adley/services/trackbacks/359543.html笛卡尔（Descartes）积的定义：
设A,B为集合，用A中元素为第一元素，B中元素为第二元素构成的有序对，所有这样的有序对组成的集合叫做A与B的笛卡尔积，记作AxB.
笛卡尔积的符号化为：
AxB={<x,y>|x∈A∧y∈B}
例如，A={a,b},B={0,1,2},则
AxB={<a,o>,<a,1>,<a,2>,<b,0>,<b,1>,<b,2>,}
BxA={<0,a>,<0,b>,<1,a>,<1,b>,<2,a>,<2,b>}
笛卡尔积的运算性质
1.对任意集合A，根据定义有
AxΦ =Φ ，Φ xA=Φ
2.一般地说，笛卡尔积运算不满足交换律，即
AxB≠BxA(当A≠Φ ∧B≠Φ∧A≠B时)

Java类
public final class Descartes {
    private List<List<Long>> finalSet = new LinkedList<List<Long>>(); //笛卡尔积
    private List<List<Long>> newStates = new LinkedList<List<Long>>(); //状态集合，被用来计算笛卡尔积的中间状态
    private boolean abort = false; //遇空终止

    public final Descartes compute(List<Long> inputSet) {
        if (abort) {
            return this;
        }
        //空集防御
        if (inputSet == null || inputSet.size() == 0) {
            finalSet = new LinkedList<List<Long>>();//空集
            abort = true;
            return this;
        }
        if (finalSet.size() == 0) {//如果finalSet为空，则把输入的集合当做finalSet
            for (Long element : inputSet) {
                List<Long> set = new LinkedList<Long>();
                set.add(element);
                finalSet.add(set);
            }
        } else {
            for (List<Long> originalSet : finalSet) {
                for (Long set : inputSet) {
                    List<Long> newState = new LinkedList<Long>();
                    newState.addAll(originalSet); //把初始中的每个集合拿出来和输入的集合的每个元素组合成一个新的集合
                    newState.add(set);
                    newStates.add(newState);
                }
            }
            if (newStates.size() > 0) {
                finalSet = newStates;
                newStates = new LinkedList<List<Long>>();
            }
        }
        return this;
    }
    public final List<List<Long>> getResult() {
        return finalSet;
    }
}

测试代码
public final class DescartesTest {
    public static void main(String[] args) {
        Descartes descartes = new Descartes();
        List<Long> set1 = new LinkedList<Long>();
        set1.add(1l);
        set1.add(2l);
        List<Long> set2 = new LinkedList<Long>();
        set2.add(2l);
        set2.add(3l);
        List<Long> set3= new LinkedList<Long>();
        set3.add(2l);
        set3.add(3l);
        descartes.compute(set1).compute(set2).compute(set3);
        System.out.println(descartes.getResult());
    }

}
输出：
[[1, 2, 2], [1, 2, 3], [1, 3, 2], [1, 3, 3], [2, 2, 2], [2, 2, 3], [2, 3, 2], [2, 3, 3]]


Adley 2011-09-26 16:02 发表评论
]]>