【转】决策树C4.5算法

 

Java代码

1. 数据挖掘中决策树C4.5预测算法实现(半成品，还要写规则后煎支及对非离散数据信息增益计算)，下一篇博客讲原理  

数据挖掘中决策树C4.5预测算法实现(半成品，还要写规则后煎支及对非离散数据信息增益计算)，下一篇博客讲原理

Java代码

1. package org.struct.decisiontree;   
2.   
3. import java.util.ArrayList;   
4. import java.util.Arrays;   
5. import java.util.List;   
6. import java.util.TreeSet;   
7.   
8. /**  
9.  * @author Leon.Chen  
10.  */  
11. public class DecisionTreeBaseC4p5 {   
12.        
13.     /**  
14.      * root node  
15.      */  
16.     private DecisionTreeNode root;   
17.   
18.     /**  
19.      * visableArray  
20.      */  
21.     private boolean[] visable;   
22.   
23.     private static final int NOT_FOUND = -1;   
24.   
25.     private static final int DATA_START_LINE = 1;   
26.   
27.     private Object[] trainingArray;   
28.   
29.     private String[] columnHeaderArray;   
30.   
31.     /**  
32.      * forecast node index  
33.      */  
34.     private int nodeIndex;   
35.   
36.     /**  
37.      * @param args  
38.      */  
39.     @SuppressWarnings("boxing")   
40.     public static void main(String[] args) {   
41.         Object[] array = new Object[] {   
42.                 new String[] { "age",          "income",   "student", "credit_rating", "buys_computer" },   
43.                 new String[] { "youth",        "high",     "no",      "fair",          "no"  },   
44.                 new String[] { "youth",        "high",     "no",      "excellent",     "no"  },   
45.                 new String[] { "middle_aged",  "high",     "no",      "fair",          "yes" },   
46.                 new String[] { "senior",       "medium",   "no",      "fair",          "yes" },   
47.                 new String[] { "senior",       "low",      "yes",     "fair",          "yes" },   
48.                 new String[] { "senior",       "low",      "yes",     "excellent",     "no"  },   
49.                 new String[] { "middle_aged",  "low",      "yes",     "excellent",     "yes" },   
50.                 new String[] { "youth",        "medium",   "no",      "fair",          "no"  },   
51.                 new String[] { "youth",        "low",      "yes",     "fair",          "yes" },   
52.                 new String[] { "senior",       "medium",   "yes",     "fair",          "yes" },   
53.                 new String[] { "youth",        "medium",   "yes",     "excellent",     "yes" },   
54.                 new String[] { "middle_aged",  "medium",   "no",      "excellent",     "yes" },   
55.                 new String[] { "middle_aged",  "high",     "yes",     "fair",          "yes" },   
56.                 new String[] { "senior",       "medium",   "no",      "excellent",     "no"  },   
57.         };   
58.   
59.         DecisionTreeBaseC4p5 tree = new DecisionTreeBaseC4p5();   
60.         tree.create(array, 4);   
61.         System.out.println("===============END PRINT TREE===============");   
62.         System.out.println("===============DECISION RESULT===============");   
63.         //tree.forecast(printData, tree.root);   
64.     }   
65.   
66.     /**  
67.      * @param printData  
68.      * @param node  
69.      */  
70.     public void forecast(String[] printData, DecisionTreeNode node) {   
71.         int index = getColumnHeaderIndexByName(node.nodeName);   
72.         if (index == NOT_FOUND) {   
73.             System.out.println(node.nodeName);   
74.         }   
75.         DecisionTreeNode[] childs = node.childNodesArray;   
76.         for (int i = 0; i < childs.length; i++) {   
77.             if (childs[i] != null) {   
78.                 if (childs[i].parentArrtibute.equals(printData[index])) {   
79.                     forecast(printData, childs[i]);   
80.                 }   
81.             }   
82.         }   
83.     }   
84.   
85.     /**  
86.      * @param array  
87.      * @param index  
88.      */  
89.     public void create(Object[] array, int index) {   
90.         this.trainingArray = Arrays.copyOfRange(array, DATA_START_LINE,   
91.                 array.length);   
92.         init(array, index);   
93.         createDecisionTree(this.trainingArray);   
94.         printDecisionTree(root);   
95.     }   
96.   
97.     /**  
98.      * @param array  
99.      * @return Object[]  
100.      */  
101.     @SuppressWarnings("boxing")   
102.     public Object[] getMaxGain(Object[] array) {   
103.         Object[] result = new Object[2];   
104.         double gain = 0;   
105.         int index = -1;   
106.   
107.         for (int i = 0; i < visable.length; i++) {   
108.             if (!visable[i]) {   
109.                 //TODO ID3 change to C4.5   
110.                 double value = gainRatio(array, i, this.nodeIndex);   
111.                 System.out.println(value);   
112.                 if (gain < value) {   
113.                     gain = value;   
114.                     index = i;   
115.                 }   
116.             }   
117.         }   
118.         result[0] = gain;   
119.         result[1] = index;   
120.         // TODO throws can't forecast this model exception   
121.         if (index != -1) {   
122.             visable[index] = true;   
123.         }   
124.         return result;   
125.     }   
126.   
127.     /**  
128.      * @param array  
129.      */  
130.     public void createDecisionTree(Object[] array) {   
131.         Object[] maxgain = getMaxGain(array);   
132.         if (root == null) {   
133.             root = new DecisionTreeNode();   
134.             root.parentNode = null;   
135.             root.parentArrtibute = null;   
136.             root.arrtibutesArray = getArrtibutesArray(((Integer) maxgain[1])   
137.                     .intValue());   
138.             root.nodeName = getColumnHeaderNameByIndex(((Integer) maxgain[1])   
139.                     .intValue());   
140.             root.childNodesArray = new DecisionTreeNode[root.arrtibutesArray.length];   
141.             insertDecisionTree(array, root);   
142.         }   
143.     }   
144.   
145.     /**  
146.      * @param array  
147.      * @param parentNode  
148.      */  
149.     public void insertDecisionTree(Object[] array, DecisionTreeNode parentNode) {   
150.         String[] arrtibutes = parentNode.arrtibutesArray;   
151.         for (int i = 0; i < arrtibutes.length; i++) {   
152.             Object[] pickArray = pickUpAndCreateSubArray(array, arrtibutes[i],   
153.                     getColumnHeaderIndexByName(parentNode.nodeName));   
154.             Object[] info = getMaxGain(pickArray);   
155.             double gain = ((Double) info[0]).doubleValue();   
156.             if (gain != 0) {   
157.                 int index = ((Integer) info[1]).intValue();   
158.                 DecisionTreeNode currentNode = new DecisionTreeNode();   
159.                 currentNode.parentNode = parentNode;   
160.                 currentNode.parentArrtibute = arrtibutes[i];   
161.                 currentNode.arrtibutesArray = getArrtibutesArray(index);   
162.                 currentNode.nodeName = getColumnHeaderNameByIndex(index);   
163.                 currentNode.childNodesArray = new DecisionTreeNode[currentNode.arrtibutesArray.length];   
164.                 parentNode.childNodesArray[i] = currentNode;   
165.                 insertDecisionTree(pickArray, currentNode);   
166.             } else {   
167.                 DecisionTreeNode leafNode = new DecisionTreeNode();   
168.                 leafNode.parentNode = parentNode;   
169.                 leafNode.parentArrtibute = arrtibutes[i];   
170.                 leafNode.arrtibutesArray = new String[0];   
171.                 leafNode.nodeName = getLeafNodeName(pickArray,this.nodeIndex);   
172.                 leafNode.childNodesArray = new DecisionTreeNode[0];   
173.                 parentNode.childNodesArray[i] = leafNode;   
174.             }   
175.         }   
176.     }   
177.   
178.     /**  
179.      * @param node  
180.      */  
181.     public void printDecisionTree(DecisionTreeNode node) {   
182.         System.out.println(node.nodeName);   
183.         DecisionTreeNode[] childs = node.childNodesArray;   
184.         for (int i = 0; i < childs.length; i++) {   
185.             if (childs[i] != null) {   
186.                 System.out.println(childs[i].parentArrtibute);   
187.                 printDecisionTree(childs[i]);   
188.             }   
189.         }   
190.     }   
191.   
192.     /**  
193.      * init data  
194.      *   
195.      * @param dataArray  
196.      * @param index  
197.      */  
198.     public void init(Object[] dataArray, int index) {   
199.         this.nodeIndex = index;   
200.         // init data   
201.         this.columnHeaderArray = (String[]) dataArray[0];   
202.         visable = new boolean[((String[]) dataArray[0]).length];   
203.         for (int i = 0; i < visable.length; i++) {   
204.             if (i == index) {   
205.                 visable[i] = true;   
206.             } else {   
207.                 visable[i] = false;   
208.             }   
209.         }   
210.     }   
211.   
212.     /**  
213.      * @param array  
214.      * @param arrtibute  
215.      * @param index  
216.      * @return Object[]  
217.      */  
218.     public Object[] pickUpAndCreateSubArray(Object[] array, String arrtibute,   
219.             int index) {   
220.         List<String[]> list = new ArrayList<String[]>();   
221.         for (int i = 0; i < array.length; i++) {   
222.             String[] strs = (String[]) array[i];   
223.             if (strs[index].equals(arrtibute)) {   
224.                 list.add(strs);   
225.             }   
226.         }   
227.         return list.toArray();   
228.     }   
229.   
230.     /**  
231.      * gain(A)  
232.      *   
233.      * @param array  
234.      * @param index  
235.      * @return double  
236.      */  
237.     public double gain(Object[] array, int index, int nodeIndex) {   
238.         int[] counts = separateToSameValueArrays(array, nodeIndex);   
239.         String[] arrtibutes = getArrtibutesArray(index);   
240.         double infoD = infoD(array, counts);   
241.         double infoaD = infoaD(array, index, nodeIndex, arrtibutes);   
242.         return infoD - infoaD;   
243.     }   
244.   
245.     /**  
246.      * @param array  
247.      * @param nodeIndex  
248.      * @return  
249.      */  
250.     public int[] separateToSameValueArrays(Object[] array, int nodeIndex) {   
251.         String[] arrti = getArrtibutesArray(nodeIndex);   
252.         int[] counts = new int[arrti.length];   
253.         for (int i = 0; i < counts.length; i++) {   
254.             counts[i] = 0;   
255.         }   
256.         for (int i = 0; i < array.length; i++) {   
257.             String[] strs = (String[]) array[i];   
258.             for (int j = 0; j < arrti.length; j++) {   
259.                 if (strs[nodeIndex].equals(arrti[j])) {   
260.                     counts[j]++;   
261.                 }   
262.             }   
263.         }   
264.         return counts;   
265.     }   
266.        
267.     /**  
268.      * gainRatio = gain(A)/splitInfo(A)  
269.      *   
270.      * @param array  
271.      * @param index  
272.      * @param nodeIndex  
273.      * @return  
274.      */  
275.     public double gainRatio(Object[] array,int index,int nodeIndex){   
276.         double gain = gain(array,index,nodeIndex);   
277.         int[] counts = separateToSameValueArrays(array, index);   
278.         double splitInfo = splitInfoaD(array,counts);   
279.         if(splitInfo != 0){   
280.             return gain/splitInfo;   
281.         }   
282.         return 0;   
283.     }   
284.   
285.     /**  
286.      * infoD = -E(pi*log2 pi)  
287.      *   
288.      * @param array  
289.      * @param counts  
290.      * @return  
291.      */  
292.     public double infoD(Object[] array, int[] counts) {   
293.         double infoD = 0;   
294.         for (int i = 0; i < counts.length; i++) {   
295.             infoD += DecisionTreeUtil.info(counts[i], array.length);   
296.         }   
297.         return infoD;   
298.     }   
299.   
300.     /**  
301.      * splitInfoaD = -E|Dj|/|D|*log2(|Dj|/|D|)  
302.      *   
303.      * @param array  
304.      * @param counts  
305.      * @return  
306.      */  
307.     public double splitInfoaD(Object[] array, int[] counts) {   
308.         return infoD(array, counts);   
309.     }   
310.   
311.     /**  
312.      * infoaD = E(|Dj| / |D|) * info(Dj)  
313.      *   
314.      * @param array  
315.      * @param index  
316.      * @param arrtibutes  
317.      * @return  
318.      */  
319.     public double infoaD(Object[] array, int index, int nodeIndex,   
320.             String[] arrtibutes) {   
321.         double sv_total = 0;   
322.         for (int i = 0; i < arrtibutes.length; i++) {   
323.             sv_total += infoDj(array, index, nodeIndex, arrtibutes[i],   
324.                     array.length);   
325.         }   
326.         return sv_total;   
327.     }   
328.   
329.     /**  
330.      * ((|Dj| / |D|) * Info(Dj))  
331.      *   
332.      * @param array  
333.      * @param index  
334.      * @param arrtibute  
335.      * @param allTotal  
336.      * @return double  
337.      */  
338.     public double infoDj(Object[] array, int index, int nodeIndex,   
339.             String arrtibute, int allTotal) {   
340.         String[] arrtibutes = getArrtibutesArray(nodeIndex);   
341.         int[] counts = new int[arrtibutes.length];   
342.         for (int i = 0; i < counts.length; i++) {   
343.             counts[i] = 0;   
344.         }   
345.   
346.         for (int i = 0; i < array.length; i++) {   
347.             String[] strs = (String[]) array[i];   
348.             if (strs[index].equals(arrtibute)) {   
349.                 for (int k = 0; k < arrtibutes.length; k++) {   
350.                     if (strs[nodeIndex].equals(arrtibutes[k])) {   
351.                         counts[k]++;   
352.                     }   
353.                 }   
354.             }   
355.         }   
356.   
357.         int total = 0;   
358.         double infoDj = 0;   
359.         for (int i = 0; i < counts.length; i++) {   
360.             total += counts[i];   
361.         }   
362.         for (int i = 0; i < counts.length; i++) {   
363.             infoDj += DecisionTreeUtil.info(counts[i], total);   
364.         }   
365.         return DecisionTreeUtil.getPi(total, allTotal) * infoDj;   
366.     }   
367.   
368.     /**  
369.      * @param index  
370.      * @return String[]  
371.      */  
372.     @SuppressWarnings("unchecked")   
373.     public String[] getArrtibutesArray(int index) {   
374.         TreeSet<String> set = new TreeSet<String>(new SequenceComparator());   
375.         for (int i = 0; i < trainingArray.length; i++) {   
376.             String[] strs = (String[]) trainingArray[i];   
377.             set.add(strs[index]);   
378.         }   
379.         String[] result = new String[set.size()];   
380.         return set.toArray(result);   
381.     }   
382.   
383.     /**  
384.      * @param index  
385.      * @return String  
386.      */  
387.     public String getColumnHeaderNameByIndex(int index) {   
388.         for (int i = 0; i < columnHeaderArray.length; i++) {   
389.             if (i == index) {   
390.                 return columnHeaderArray[i];   
391.             }   
392.         }   
393.         return null;   
394.     }   
395.   
396.     /**  
397.      * @param array  
398.      * @return String  
399.      */  
400.     public String getLeafNodeName(Object[] array,int nodeIndex) {   
401.         if (array != null && array.length > 0) {   
402.             String[] strs = (String[]) array[0];   
403.             return strs[nodeIndex];   
404.         }   
405.         return null;   
406.     }   
407.   
408.     /**  
409.      * @param name  
410.      * @return int  
411.      */  
412.     public int getColumnHeaderIndexByName(String name) {   
413.         for (int i = 0; i < columnHeaderArray.length; i++) {   
414.             if (name.equals(columnHeaderArray[i])) {   
415.                 return i;   
416.             }   
417.         }   
418.         return NOT_FOUND;   
419.     }   
420. }  

package org.struct.decisiontree;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TreeSet;

/**
 * @author Leon.Chen
 */
public class DecisionTreeBaseC4p5 {
	
	/**
	 * root node
	 */
	private DecisionTreeNode root;

	/**
	 * visableArray
	 */
	private boolean[] visable;

	private static final int NOT_FOUND = -1;

	private static final int DATA_START_LINE = 1;

	private Object[] trainingArray;

	private String[] columnHeaderArray;

	/**
	 * forecast node index
	 */
	private int nodeIndex;

	/**
	 * @param args
	 */
	@SuppressWarnings("boxing")
	public static void main(String[] args) {
		Object[] array = new Object[] {
				new String[] { "age",          "income",   "student", "credit_rating", "buys_computer" },
				new String[] { "youth",        "high",     "no",      "fair",          "no"  },
				new String[] { "youth",        "high",     "no",      "excellent",     "no"  },
				new String[] { "middle_aged",  "high",     "no",      "fair",          "yes" },
				new String[] { "senior",       "medium",   "no",      "fair",          "yes" },
				new String[] { "senior",       "low",      "yes",     "fair",          "yes" },
				new String[] { "senior",       "low",      "yes",     "excellent",     "no"  },
				new String[] { "middle_aged",  "low",      "yes",     "excellent",     "yes" },
				new String[] { "youth",        "medium",   "no",      "fair",          "no"  },
				new String[] { "youth",        "low",      "yes",     "fair",          "yes" },
				new String[] { "senior",       "medium",   "yes",     "fair",          "yes" },
				new String[] { "youth",        "medium",   "yes",     "excellent",     "yes" },
				new String[] { "middle_aged",  "medium",   "no",      "excellent",     "yes" },
				new String[] { "middle_aged",  "high",     "yes",     "fair",          "yes" },
				new String[] { "senior",       "medium",   "no",      "excellent",     "no"  },
		};

		DecisionTreeBaseC4p5 tree = new DecisionTreeBaseC4p5();
		tree.create(array, 4);
		System.out.println("===============END PRINT TREE===============");
		System.out.println("===============DECISION RESULT===============");
		//tree.forecast(printData, tree.root);
	}

	/**
	 * @param printData
	 * @param node
	 */
	public void forecast(String[] printData, DecisionTreeNode node) {
		int index = getColumnHeaderIndexByName(node.nodeName);
		if (index == NOT_FOUND) {
			System.out.println(node.nodeName);
		}
		DecisionTreeNode[] childs = node.childNodesArray;
		for (int i = 0; i < childs.length; i++) {
			if (childs[i] != null) {
				if (childs[i].parentArrtibute.equals(printData[index])) {
					forecast(printData, childs[i]);
				}
			}
		}
	}

	/**
	 * @param array
	 * @param index
	 */
	public void create(Object[] array, int index) {
		this.trainingArray = Arrays.copyOfRange(array, DATA_START_LINE,
				array.length);
		init(array, index);
		createDecisionTree(this.trainingArray);
		printDecisionTree(root);
	}

	/**
	 * @param array
	 * @return Object[]
	 */
	@SuppressWarnings("boxing")
	public Object[] getMaxGain(Object[] array) {
		Object[] result = new Object[2];
		double gain = 0;
		int index = -1;

		for (int i = 0; i < visable.length; i++) {
			if (!visable[i]) {
				//TODO ID3 change to C4.5
				double value = gainRatio(array, i, this.nodeIndex);
				System.out.println(value);
				if (gain < value) {
					gain = value;
					index = i;
				}
			}
		}
		result[0] = gain;
		result[1] = index;
		// TODO throws can't forecast this model exception
		if (index != -1) {
			visable[index] = true;
		}
		return result;
	}

	/**
	 * @param array
	 */
	public void createDecisionTree(Object[] array) {
		Object[] maxgain = getMaxGain(array);
		if (root == null) {
			root = new DecisionTreeNode();
			root.parentNode = null;
			root.parentArrtibute = null;
			root.arrtibutesArray = getArrtibutesArray(((Integer) maxgain[1])
					.intValue());
			root.nodeName = getColumnHeaderNameByIndex(((Integer) maxgain[1])
					.intValue());
			root.childNodesArray = new DecisionTreeNode[root.arrtibutesArray.length];
			insertDecisionTree(array, root);
		}
	}

	/**
	 * @param array
	 * @param parentNode
	 */
	public void insertDecisionTree(Object[] array, DecisionTreeNode parentNode) {
		String[] arrtibutes = parentNode.arrtibutesArray;
		for (int i = 0; i < arrtibutes.length; i++) {
			Object[] pickArray = pickUpAndCreateSubArray(array, arrtibutes[i],
					getColumnHeaderIndexByName(parentNode.nodeName));
			Object[] info = getMaxGain(pickArray);
			double gain = ((Double) info[0]).doubleValue();
			if (gain != 0) {
				int index = ((Integer) info[1]).intValue();
				DecisionTreeNode currentNode = new DecisionTreeNode();
				currentNode.parentNode = parentNode;
				currentNode.parentArrtibute = arrtibutes[i];
				currentNode.arrtibutesArray = getArrtibutesArray(index);
				currentNode.nodeName = getColumnHeaderNameByIndex(index);
				currentNode.childNodesArray = new DecisionTreeNode[currentNode.arrtibutesArray.length];
				parentNode.childNodesArray[i] = currentNode;
				insertDecisionTree(pickArray, currentNode);
			} else {
				DecisionTreeNode leafNode = new DecisionTreeNode();
				leafNode.parentNode = parentNode;
				leafNode.parentArrtibute = arrtibutes[i];
				leafNode.arrtibutesArray = new String[0];
				leafNode.nodeName = getLeafNodeName(pickArray,this.nodeIndex);
				leafNode.childNodesArray = new DecisionTreeNode[0];
				parentNode.childNodesArray[i] = leafNode;
			}
		}
	}

	/**
	 * @param node
	 */
	public void printDecisionTree(DecisionTreeNode node) {
		System.out.println(node.nodeName);
		DecisionTreeNode[] childs = node.childNodesArray;
		for (int i = 0; i < childs.length; i++) {
			if (childs[i] != null) {
				System.out.println(childs[i].parentArrtibute);
				printDecisionTree(childs[i]);
			}
		}
	}

	/**
	 * init data
	 * 
	 * @param dataArray
	 * @param index
	 */
	public void init(Object[] dataArray, int index) {
		this.nodeIndex = index;
		// init data
		this.columnHeaderArray = (String[]) dataArray[0];
		visable = new boolean[((String[]) dataArray[0]).length];
		for (int i = 0; i < visable.length; i++) {
			if (i == index) {
				visable[i] = true;
			} else {
				visable[i] = false;
			}
		}
	}

	/**
	 * @param array
	 * @param arrtibute
	 * @param index
	 * @return Object[]
	 */
	public Object[] pickUpAndCreateSubArray(Object[] array, String arrtibute,
			int index) {
		List<String[]> list = new ArrayList<String[]>();
		for (int i = 0; i < array.length; i++) {
			String[] strs = (String[]) array[i];
			if (strs[index].equals(arrtibute)) {
				list.add(strs);
			}
		}
		return list.toArray();
	}

	/**
	 * gain(A)
	 * 
	 * @param array
	 * @param index
	 * @return double
	 */
	public double gain(Object[] array, int index, int nodeIndex) {
		int[] counts = separateToSameValueArrays(array, nodeIndex);
		String[] arrtibutes = getArrtibutesArray(index);
		double infoD = infoD(array, counts);
		double infoaD = infoaD(array, index, nodeIndex, arrtibutes);
		return infoD - infoaD;
	}

	/**
	 * @param array
	 * @param nodeIndex
	 * @return
	 */
	public int[] separateToSameValueArrays(Object[] array, int nodeIndex) {
		String[] arrti = getArrtibutesArray(nodeIndex);
		int[] counts = new int[arrti.length];
		for (int i = 0; i < counts.length; i++) {
			counts[i] = 0;
		}
		for (int i = 0; i < array.length; i++) {
			String[] strs = (String[]) array[i];
			for (int j = 0; j < arrti.length; j++) {
				if (strs[nodeIndex].equals(arrti[j])) {
					counts[j]++;
				}
			}
		}
		return counts;
	}
	
	/**
	 * gainRatio = gain(A)/splitInfo(A)
	 * 
	 * @param array
	 * @param index
	 * @param nodeIndex
	 * @return
	 */
	public double gainRatio(Object[] array,int index,int nodeIndex){
		double gain = gain(array,index,nodeIndex);
		int[] counts = separateToSameValueArrays(array, index);
		double splitInfo = splitInfoaD(array,counts);
		if(splitInfo != 0){
			return gain/splitInfo;
		}
		return 0;
	}

	/**
	 * infoD = -E(pi*log2 pi)
	 * 
	 * @param array
	 * @param counts
	 * @return
	 */
	public double infoD(Object[] array, int[] counts) {
		double infoD = 0;
		for (int i = 0; i < counts.length; i++) {
			infoD += DecisionTreeUtil.info(counts[i], array.length);
		}
		return infoD;
	}

	/**
	 * splitInfoaD = -E|Dj|/|D|*log2(|Dj|/|D|)
	 * 
	 * @param array
	 * @param counts
	 * @return
	 */
	public double splitInfoaD(Object[] array, int[] counts) {
		return infoD(array, counts);
	}

	/**
	 * infoaD = E(|Dj| / |D|) * info(Dj)
	 * 
	 * @param array
	 * @param index
	 * @param arrtibutes
	 * @return
	 */
	public double infoaD(Object[] array, int index, int nodeIndex,
			String[] arrtibutes) {
		double sv_total = 0;
		for (int i = 0; i < arrtibutes.length; i++) {
			sv_total += infoDj(array, index, nodeIndex, arrtibutes[i],
					array.length);
		}
		return sv_total;
	}

	/**
	 * ((|Dj| / |D|) * Info(Dj))
	 * 
	 * @param array
	 * @param index
	 * @param arrtibute
	 * @param allTotal
	 * @return double
	 */
	public double infoDj(Object[] array, int index, int nodeIndex,
			String arrtibute, int allTotal) {
		String[] arrtibutes = getArrtibutesArray(nodeIndex);
		int[] counts = new int[arrtibutes.length];
		for (int i = 0; i < counts.length; i++) {
			counts[i] = 0;
		}

		for (int i = 0; i < array.length; i++) {
			String[] strs = (String[]) array[i];
			if (strs[index].equals(arrtibute)) {
				for (int k = 0; k < arrtibutes.length; k++) {
					if (strs[nodeIndex].equals(arrtibutes[k])) {
						counts[k]++;
					}
				}
			}
		}

		int total = 0;
		double infoDj = 0;
		for (int i = 0; i < counts.length; i++) {
			total += counts[i];
		}
		for (int i = 0; i < counts.length; i++) {
			infoDj += DecisionTreeUtil.info(counts[i], total);
		}
		return DecisionTreeUtil.getPi(total, allTotal) * infoDj;
	}

	/**
	 * @param index
	 * @return String[]
	 */
	@SuppressWarnings("unchecked")
	public String[] getArrtibutesArray(int index) {
		TreeSet<String> set = new TreeSet<String>(new SequenceComparator());
		for (int i = 0; i < trainingArray.length; i++) {
			String[] strs = (String[]) trainingArray[i];
			set.add(strs[index]);
		}
		String[] result = new String[set.size()];
		return set.toArray(result);
	}

	/**
	 * @param index
	 * @return String
	 */
	public String getColumnHeaderNameByIndex(int index) {
		for (int i = 0; i < columnHeaderArray.length; i++) {
			if (i == index) {
				return columnHeaderArray[i];
			}
		}
		return null;
	}

	/**
	 * @param array
	 * @return String
	 */
	public String getLeafNodeName(Object[] array,int nodeIndex) {
		if (array != null && array.length > 0) {
			String[] strs = (String[]) array[0];
			return strs[nodeIndex];
		}
		return null;
	}

	/**
	 * @param name
	 * @return int
	 */
	public int getColumnHeaderIndexByName(String name) {
		for (int i = 0; i < columnHeaderArray.length; i++) {
			if (name.equals(columnHeaderArray[i])) {
				return i;
			}
		}
		return NOT_FOUND;
	}
}

Java代码

1. package org.struct.decisiontree;   
2.   
3. /**  
4.  * @author Leon.Chen  
5.  */  
6. public class DecisionTreeNode {   
7.   
8.     DecisionTreeNode parentNode;   
9.   
10.     String parentArrtibute;   
11.   
12.     String nodeName;   
13.   
14.     String[] arrtibutesArray;   
15.   
16.     DecisionTreeNode[] childNodesArray;   
17.   
18. }  

package org.struct.decisiontree;

/**
 * @author Leon.Chen
 */
public class DecisionTreeNode {

	DecisionTreeNode parentNode;

	String parentArrtibute;

	String nodeName;

	String[] arrtibutesArray;

	DecisionTreeNode[] childNodesArray;

}

Java代码

1. package org.struct.decisiontree;   
2.   
3. /**  
4.  * @author Leon.Chen  
5.  */  
6. public class DecisionTreeUtil {   
7.   
8.     /**  
9.      * entropy:Info(T)=(i=1...k)pi*log（2）pi  
10.      *   
11.      * @param x  
12.      * @param total  
13.      * @return double  
14.      */  
15.     public static double info(int x, int total) {   
16.         if (x == 0) {   
17.             return 0;   
18.         }   
19.         double x_pi = getPi(x, total);   
20.         return -(x_pi * logYBase2(x_pi));   
21.     }   
22.   
23.     /**  
24.      * log2y  
25.      *   
26.      * @param y  
27.      * @return double  
28.      */  
29.     public static double logYBase2(double y) {   
30.         return Math.log(y) / Math.log(2);   
31.     }   
32.   
33.     /**  
34.      * pi=|C(i,d)|/|D|  
35.      *   
36.      * @param x  
37.      * @param total  
38.      * @return double  
39.      */  
40.     public static double getPi(int x, int total) {   
41.         return x / (double) total;   
42.     }   
43.   
44. }  

package org.struct.decisiontree;

/**
 * @author Leon.Chen
 */
public class DecisionTreeUtil {

	/**
	 * entropy:Info(T)=(i=1...k)pi*log（2）pi
	 * 
	 * @param x
	 * @param total
	 * @return double
	 */
	public static double info(int x, int total) {
		if (x == 0) {
			return 0;
		}
		double x_pi = getPi(x, total);
		return -(x_pi * logYBase2(x_pi));
	}

	/**
	 * log2y
	 * 
	 * @param y
	 * @return double
	 */
	public static double logYBase2(double y) {
		return Math.log(y) / Math.log(2);
	}

	/**
	 * pi=|C(i,d)|/|D|
	 * 
	 * @param x
	 * @param total
	 * @return double
	 */
	public static double getPi(int x, int total) {
		return x / (double) total;
	}

}

Java代码

1. package org.struct.decisiontree;   
2.   
3. import java.util.Comparator;   
4.   
5. /**  
6.  * @author Leon.Chen  
7.  *   
8.  */  
9. @SuppressWarnings("unchecked")   
10. public class SequenceComparator implements Comparator {   
11.   
12.     public int compare(Object o1, Object o2) throws ClassCastException {   
13.         String str1 = (String) o1;   
14.         String str2 = (String) o2;   
15.         return str1.compareTo(str2);   
16.     }   
17. }