笛卡尔乘积运算结果的输出{n1,n2...}*{m1,m2,m3..}*{p1,p2,p3...}*

1. import java.util.ArrayList;
2. import java.util.Stack;
4. /**
5.  *
6.  * 实现笛卡尔乘积运算结果的输出：
7.  *  {n1,n2...}*{m1,m2,m3..}*{p1,p2,p3...}*....
8.  *  模型非常类似树的先根遍历算法或图的深度优先搜索算法(有些勉强),如果输入是:
9.  *     {n1,n2}*{m1,m2,m3}*{p1,p2,p3}
10.  *  那么搜索模型是:
11.  *   root-->n1--->m1--->p1
12.  *                  --->p2
13.  *                  --->p3
14.  *            --->m2--->p1
15.  *                  --->p2
16.  *                  --->p3
17.  *            --->m3--->p1
18.  *                  --->p2
19.  *                  --->p3
20.  *   root-->n2--->m1--->p1
21.  *                  --->p2
22.  *                  --->p3
23.  *            --->m2--->p1
24.  *                  --->p2
25.  *                  --->p3
26.  *            --->m3--->p1
27.  *                  --->p2
28.  *                  --->p3
29.  * 从上面可以看到从root出发,访问出来的模型就是一颗树,root表示第一次层次.
30.  * 每次从树的第二层节点出发到树的叶子节点结束,所访问过的节点记录就是一个笛卡尔乘积运算结果.
31.  * 
32.  */
33. public class DescartesMultiplication {
34.      
35.     public static void main(String[] args) {
36.         
37.         //initiate all of data:
38.         ArrayList list1= new ArrayList();
39.         ArrayList list2= new ArrayList();
40.         ArrayList list3= new ArrayList();
41.         ArrayList list4= new ArrayList();
42.         ArrayList root= new ArrayList();
43.         
44. //        list1.add("1");
45. //        list2.add("2");
46. //        list2.add("3");
47. //        list3.add("4");
48. //        list3.add("5");
49. //        list3.add("6");
50. //        list3.add("7");
51. //        list4.add("8");
52. //        list4.add("9");
53.         
54.         list1.add(1);
55.         list2.add(2);
56.         list2.add("1");
57.         list2.add(3.3);
58.         list3.add(4.4);
59.         list3.add(5);
60.         list3.add(6.5);
61.         list3.add(7.0);
62.         list4.add(8.2);
63.         list4.add(9.1);
64.         list4.add(new Object());
65.         
66.         root.add(list1);
67.         root.add(list2);
68.         root.add(list3);
69.         root.add(list4);
70.         
71.         //print all of data:
72.         for (int i = 0; i < root.size(); i++) {
73.             ArrayList list=new ArrayList();
74.             ArrayList item = (ArrayList) root.get(i);
75.             for (int j = 0; j < item.size(); j++) {
76.                 Object element =  item.get(j);
77.                 list.add(element);
78.             }
79.             printArrayList(list);
80.         }
81.         
82.         //begin to a depth-first search traverse from the root node.
83.         System.out.println("-----Below is a result of DescartesMultiplication-----");
84.         
85.         /**
86.          * 当树的总层次数>1时,注意树的总层次数=root.size()-1.
87.          */
88.         if(root.size()>0){
89.             /**
90.              * 得到第二层次上所有的树节点.
91.              */
92.             ArrayList nodeList = (ArrayList) root.get(0);
93.             
94.             /**
95.              * stack主要用来记录，一次从树的第二层节点到树的叶子节点的时候，所访问过的所有节点.
96.              */
97.             Stack<String> stack= new Stack();
98.             
99.             /**
100.              * 从树的第二层次开始先序遍历整颗树.
101.              */
102.             traverse(root,0,nodeList,stack);
103.         }
104.     }
105.     
106.     public static void printArrayList(ArrayList list){
107.        StringBuffer sb=new StringBuffer();
108.        sb.append("{");
109.        for (int i = 0; i < list.size(); i++) {
110.            sb.append(list.get(i).toString()+",");
111.        }
112.        sb.deleteCharAt(sb.length()-1);
113.        sb.append("}");
114.        System.out.println(sb.toString());
115.     }
116.     
117.     public static void printArrayList(Object[] array){
118.         StringBuffer sb=new StringBuffer();
119.         sb.append("{");
120.         for (int i = 0; i < array.length; i++) {
121.             sb.append(array[i].toString()+",");
122.         }
123.         sb.deleteCharAt(sb.length()-1);
124.         sb.append("}");
125.         System.out.println(sb.toString());
126.      }
127.     
128.     /**
129.      * 这个方法主要用来实现这种for的嵌套模型:
130.      * for()
131.      *    for()
132.      *       for()
133.      *         for()
134.      *           ...
135.      * @param root  表示整颗树
136.      * @param treeDepthCounter  记录第几层次,0表示第一层次,1表示第二层次,...
137.      * @param nodeList  记录在该树的层次上所有节点,就比如第二层的所有节点是{n1,n2}
138.      * @param stack     主要用来记录，一次从树的第二层节点到树的叶子节点的时候，所访问过的所有节点.
139.      */
140.     public static void traverse(ArrayList root,int treeDepthCounter,ArrayList nodeList, Stack stack){
141.         for (int i = 0; i < nodeList.size(); i++) {
142.             /**
143.              * 取得一个树节点
144.              */
145.             Object element = nodeList.get(i);
146.             
147.             /**
148.              * 访问该层中的一个节点,记录该节点
149.              */
150.             stack.push(element);
151.             
152.             /**
153.              * root.size()=整颗树所拥有的层次数-1
154.              * treeDepthCounter >= root.size()-1 ,表示已经到达树的叶子节点.
155.              */
156.             if( treeDepthCounter >= root.size()-1) {
157.                 /**
158.                  * 如果这次从树的第二层节点到树的叶子节点的时候结束，
159.                  * 那么打印此次搜索中访问的所有节点,stack保存该次访问过的所有节点
160.                  */
161.                 Object[] one_traverse=new Object[root.size()];
162.                 
163.                 /**
164.                  * 取出和打印当前stack中的所有记录,但是不破坏stack中的所有记录.
165.                  */
166.                 stack.copyInto(one_traverse);
167.                 printArrayList(one_traverse);
168.             }else {
169.                 /**
170.                  * 开始访问下一层次的树,nextDeepCounter为下一层次的层次数.
171.                  */
172.                 int nextDeepCounter=treeDepthCounter+1;
173.                 
174.                 /**
175.                  * 得到下一层次上所有的树节点,比如第3层次上的树节点是{m1,m2,m3}.
176.                  */
177.                 ArrayList nextNodeList = (ArrayList) root.get(nextDeepCounter);
178.                 /**
179.                  * 开始访问下一层次的树节点.
180.                  */
181.                 traverse(root,nextDeepCounter,nextNodeList,stack);    
182.             }
183.             
184.             /**
185.              * 当该节点访问结束时,从记录中删除该节点.
186.              */
187.             stack.pop();
188.         }
189.     }
190. }

 

如果输入内容为：
{1}
{2,3}
{4,5,6,7}
{8,9}

输出结果为：
{1,2,4,8}
{1,2,4,9}
{1,2,5,8}
{1,2,5,9}
{1,2,6,8}
{1,2,6,9}
{1,2,7,8}
{1,2,7,9}
{1,3,4,8}
{1,3,4,9}
{1,3,5,8}
{1,3,5,9}
{1,3,6,8}
{1,3,6,9}
{1,3,7,8}
{1,3,7,9}


如果输入内容为：
{1}
{2,1,3.3}
{4.4,5,6.5,7.0}
{8.2,9.1,java.lang.Object@3a803a80}

那么输出结果为：
{1,2,4.4,8.2}
{1,2,4.4,9.1}
{1,2,4.4,java.lang.Object@3a803a80}
{1,2,5,8.2}
{1,2,5,9.1}
{1,2,5,java.lang.Object@3a803a80}
{1,2,6.5,8.2}
{1,2,6.5,9.1}
{1,2,6.5,java.lang.Object@3a803a80}
{1,2,7.0,8.2}
{1,2,7.0,9.1}
{1,2,7.0,java.lang.Object@3a803a80}
{1,1,4.4,8.2}
{1,1,4.4,9.1}
{1,1,4.4,java.lang.Object@3a803a80}
{1,1,5,8.2}
{1,1,5,9.1}
{1,1,5,java.lang.Object@3a803a80}
{1,1,6.5,8.2}
{1,1,6.5,9.1}
{1,1,6.5,java.lang.Object@3a803a80}
{1,1,7.0,8.2}
{1,1,7.0,9.1}
{1,1,7.0,java.lang.Object@3a803a80}
{1,3.3,4.4,8.2}
{1,3.3,4.4,9.1}
{1,3.3,4.4,java.lang.Object@3a803a80}
{1,3.3,5,8.2}
{1,3.3,5,9.1}
{1,3.3,5,java.lang.Object@3a803a80}
{1,3.3,6.5,8.2}
{1,3.3,6.5,9.1}
{1,3.3,6.5,java.lang.Object@3a803a80}
{1,3.3,7.0,8.2}
{1,3.3,7.0,9.1}
{1,3.3,7.0,java.lang.Object@3a803a80}

 

原文引自：http://www.blogjava.net/chinayuan/archive/2008/09/02/226246.html