ID3算法（Java实现）

#数据个数
datanum=14
#属性及属性值
nodeAndAttribute=年龄:青/中/老,收入:高/中/低,学生:是/否,信誉:良/优,归类:买/不买
#数据
D1=青,高,否,良,不买
D2=青,高,否,优,不买
D3=中,高,否,良,买
D4=老,中,否,良,买
D5=老,低,是,良,买
D6=老,低,是,优,不买
D7=中,低,是,优,买
D8=青,中,否,良,不买
D9=青,低,是,良,买
D10=老,中,是,良,买
D11=青,中,是,优,买
D12=中,中,否,优,买
D13=中,高,是,良,买
D14=老,中,否,优,不买
D15=老,中,否,优,买

package com.id3.node;

import java.util.HashMap;
import java.util.Map;

public class TreeNode {

    private String nodeName;
    private Map<String,Attributes> attributes;
    private double gain;
    
    public double getGain() {
        return gain;
    }
    public void setGain(double gain) {
        this.gain = gain;
    }
    public String getNodeName() {
        
        return nodeName;
    }
    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }
    public Map<String, Attributes> getAttributes() {
        return attributes;
    }
    public void setAttributes(Map<String, Attributes> attributes) {
        
        this.attributes = attributes;
    }
    
    @Override
    public String toString() {
        return "TreeNode [nodeName=" + nodeName + ", attributes=" + attributes
                + ", gain=" + gain + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((attributes == null) ? 0 : attributes.hashCode());
        long temp;
        temp = Double.doubleToLongBits(gain);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result
                + ((nodeName == null) ? 0 : nodeName.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        TreeNode other = (TreeNode) obj;
        if (attributes == null) {
            if (other.attributes != null)
                return false;
        } else if (!attributes.equals(other.attributes))
            return false;
        if (Double.doubleToLongBits(gain) != Double
                .doubleToLongBits(other.gain))
            return false;
        if (nodeName == null) {
            if (other.nodeName != null)
                return false;
        } else if (!nodeName.equals(other.nodeName))
            return false;
        return true;
    }
    
    
    
    
}


class Attributes{
    
    private String attrName;
    private TreeNode nextNode;
    private String leafName;
    private int attrNum;
    private double h;
    Map<String, Integer> resultNum = new HashMap<String, Integer>();
    
    public String getLeafName() {
        return leafName;
    }
    public void setLeafName(String leafName) {
        this.leafName = leafName;
    }
    public Map<String, Integer> getResultNum() {
        return resultNum;
    }
    public void setResultNum(Map<String, Integer> resultNum) {
        this.resultNum = resultNum;
    }
    public double getH() {
        return h;
    }
    public void setH(double h) {
        this.h = h;
    }
    public String getAttrName() {
        return attrName;
    }
    public void setAttrName(String attrName) {
        this.attrName = attrName;
    }
    public TreeNode getNextNode() {
        return nextNode;
    }
    public void setNextNode(TreeNode nextNode) {
        this.nextNode = nextNode;
    }
    public int getAttrNum() {
        return attrNum;
    }
    public void setAttrNum(int attrNum) {
        this.attrNum = attrNum;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((attrName == null) ? 0 : attrName.hashCode());
        result = prime * result + attrNum;
        long temp;
        temp = Double.doubleToLongBits(h);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result
                + ((leafName == null) ? 0 : leafName.hashCode());
        result = prime * result
                + ((nextNode == null) ? 0 : nextNode.hashCode());
        result = prime * result
                + ((resultNum == null) ? 0 : resultNum.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Attributes other = (Attributes) obj;
        if (attrName == null) {
            if (other.attrName != null)
                return false;
        } else if (!attrName.equals(other.attrName))
            return false;
        if (attrNum != other.attrNum)
            return false;
        if (Double.doubleToLongBits(h) != Double.doubleToLongBits(other.h))
            return false;
        if (leafName == null) {
            if (other.leafName != null)
                return false;
        } else if (!leafName.equals(other.leafName))
            return false;
        if (nextNode == null) {
            if (other.nextNode != null)
                return false;
        } else if (!nextNode.equals(other.nextNode))
            return false;
        if (resultNum == null) {
            if (other.resultNum != null)
                return false;
        } else if (!resultNum.equals(other.resultNum))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Attributes [attrName=" + attrName + ", nextNode=" + nextNode
                + ", leafName=" + leafName + ", attrNum=" + attrNum + ", h="
                + h + ", resultNum=" + resultNum + "]";
    }
    
}

package com.id3.node;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * ID3算法
 * @author JoMint
 *
 */
public class ID3Alogo {

    //存每个节点及其属性等相关变量
    private List<TreeNode> treeList;
    //存数据集
    private List<Map<String, String>> dataList;
    //遍历决策树时的开始节点
    private Attributes startNode;
    //决策结果变量的值
    private List<String> resultList;
    //结果属性节点
    private TreeNode resultNode;
    //决策树
    private String str;

    //构建决策树的开始调用方法
    public void ID3(String id3Name,String readPath,String printPath){
        
        //初始化成员变量
        initElement(id3Name);
        //读数据
        readData(readPath);
        //构建决策树
        cusTree(dataList, treeList, startNode);
        //System.out.println(startNode.getNextNode().getAttributes().get("Overcast").getLeafName());
        //遍历决策树，并把结果存入str中
        
        printTree(startNode,"");
        //打印决策树
        System.out.println(str);
        //输出决策树到文件
        printTreetoTxt(printPath);
        
    }
    
    /**
     * 初始化成员变量
     */
    private void initElement(String id3Name) {
        
        //存每个节点及其属性等相关变量
        treeList = new ArrayList<TreeNode>();
        //存数据集
        dataList = new ArrayList<Map<String,String>>();
        //遍历决策树时的开始节点
        startNode = new Attributes();
        //决策结果变量的值
        resultList = new ArrayList<String>();
        //结果属性节点
        TreeNode resultNode = null;
        //决策树
        str = id3Name+"决策树:\r\n";
        
    }


    /**
     * 读数据
     */
    private void readData(String path) {
        
        Map<String, String> dataMap;
        Map<String,Attributes> attrMap;
        TreeNode treeNode;
        int num;
        
        //创建读取properties文件的对象
        Properties pro = new Properties();
        
        
        try {
            //为了读取中文字符，将读取文件的类型改为字符流读取
            InputStream inputStream = new FileInputStream(path);
            BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream));
            //加载数据文件
            pro.load(bf);
            //读取数据总个数
            num = Integer.parseInt(pro.getProperty("datanum"));
            //读取属性及属性值
            String attribute = pro.getProperty("nodeAndAttribute");
            //将每个属性分开，用数组存，遍历每个属性，再把每个属性的属性值分开，存到treeList中
            String[] attArray = attribute.split(",");
            for (int i = 0; i < attArray.length; i++) {
                
                treeNode = new TreeNode();
                String[] temp = attArray[i].split(":");
                String nodeName = temp[0];
                String[] attr = temp[1].split("/");
                treeNode.setNodeName(nodeName);
                attrMap = new HashMap<String, Attributes>();
                Attributes attributes;
                for (int j = 0; j < attr.length; j++) {
                    //Map<String, Integer> map = new HashMap<String, Integer>();
                    attributes = new Attributes();
                    //map.put(attr[j], 0);
                    attributes.setAttrName(attr[j]);
                    attrMap.put(attr[j], attributes);
                    
                    //存入结果变量的值，为最后的判断做铺垫
                    if(i == attArray.length-1){
                        
                        resultList.add(attr[j]);
                        
                    }
                    
                }
                treeNode.setAttributes(attrMap);
                treeList.add(treeNode);
            }
            
            //遍历数据集，将数据按行存入dataList中
            for (int i = 1; i <= num; i++) {
                
                dataMap = new HashMap<String, String>();
                String key = "D"+i;
                String[] colline = pro.getProperty(key).split(",");
                //System.out.println(key+"=="+colline.length);
                for (int j = 0; j < treeList.size(); j++) {
                    //System.out.println(treeList.size());
                    dataMap.put(treeList.get(j).getNodeName(), colline[j]);
                }
                dataList.add(dataMap);
            }
            
            //得到结果属性的名字
            resultNode = treeList.get(treeList.size()-1);
            
            
//            System.out.println("************************resultNode==" + resultNode + "***********************");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    
    /**
     * 数据处理
     * @param cdataList
     * @param ctreeList
     */
    private List<List> dealData(List<Map<String, String>> dataList, List<TreeNode> treeList){
        
        
        List<List> returnList= new ArrayList<List>();
        int num = dataList.size();
        
        /*
         * 统计数据集中每个属性的属性值个数
         */
        Map<String, Attributes> attrMap = new HashMap<String, Attributes>();
        Map<String, Integer> resultMap;
        for (int i = 0; i < treeList.size(); i++) {
            for (int j = 0; j < dataList.size(); j++) {
                //获得当前数据集中当前列当前行的属性值
                String key = dataList.get(j).get(treeList.get(i).getNodeName()); 
                attrMap = treeList.get(i).getAttributes();
                //System.out.println(attrMap.get(key)+"=="+key);
                //计算样本中对应的属性变量的个数
                attrMap.get(key).setAttrNum(attrMap.get(key).getAttrNum()+1); 
                
                //System.out.println("->"+attrMap.get(key));
                
                //获得结果变量值
                String result = dataList.get(j).get(treeList.get(treeList.size()-1).getNodeName()); 
                resultMap = attrMap.get(key).getResultNum();
                //如果包含这个结果变量，则数量上加1; 如果不包含，赋初值为1
                if (resultMap.containsKey(result)) {      
                    resultMap.put(result, resultMap.get(result)+1);
                }else{
                    resultMap.put(result, 1);
                }
            }
        }
        /*
         * 计算熵
         */
        DecimalFormat df = new DecimalFormat("#.###");   
        for (int i = 0; i < treeList.size(); i++) {
            //遍历 Attributes
            //计算属性熵： gain
            double gain = 0.0;
            for (Map.Entry<String, Attributes> element : treeList.get(i).getAttributes().entrySet()) {
                Attributes attr = treeList.get(i).getAttributes().get(element.getKey());
                Map<String, Integer> result = attr.getResultNum();
                //遍历每个 Attributes 的 resultNum
                //计算属性值的熵 ：h
                double h = 0.0;
                for (Map.Entry<String, Integer> element2 : result.entrySet()) {
                    double resultNum = (double)result.get(element2.getKey());
                    double attrNum = (double)attr.getAttrNum();
                    resultNum = resultNum/attrNum;
                    h -= (resultNum*(Math.log(resultNum)/Math.log((double)2)));
                    h = Double.parseDouble(df.format(h));
                    attr.setH(h);
                    //System.out.println("resultNum=========="+resultNum);
                }
                //System.out.println(" attr==>"+attr);
                gain += ((double)attr.getAttrNum()/num)*attr.getH();
                gain = Double.parseDouble(df.format(gain));
                
                //System.out.println("gain=="+gain);
            }
            
            treeList.get(i).setGain(gain);
            //System.out.println(" gain-->"+treeList.get(i));
            
        }
        
        //将处理好的dataList和treeList放在returnList中返回
        returnList.add(dataList);
        returnList.add(treeList);
        
        return returnList;
        
//        System.out.println("***************************************************+++++++↓");
//        for (int i = 0; i < treeList.size(); i++) {
//            System.out.println(treeList.get(i));
//        }
//        System.out.println();
//        for (int i = 0; i < dataList.size(); i++) {
//            System.out.println(dataList.get(i));
//        }
//        
//        System.out.println("================================================="+num+"条数据=="+treeList.size()+"个属性");
//        System.out.println("***************************************************+++++++↑");
        
    }
    
    /**
     * 构建决策树
     * @param dataList
     * @param treeList
     */
    @SuppressWarnings("unchecked")
    private void cusTree(List<Map<String, String>> dataList, List<TreeNode> treeList, Attributes cAttr){
        
        List<List> curryList= new ArrayList<List>();
        
        //处理数据
        
        curryList = dealData(dataList, treeList);
        
        
        //从 curryList 中得到 dataList 和 treeList
        dataList = (List<Map<String, String>>)curryList.get(0);
        treeList = (List<TreeNode>)curryList.get(1);
        
        
        //判断当前处理的数据集中的决策结果，若决策结果相同的个数等于总的当前处理的数据集的条数，则遍历结束
        //将当前的决策结果放入当前判断的属性值的后边
        //返回到调用这个函数的父函数
        for (TreeNode treeNode : treeList) {
            if (treeNode.getNodeName().equals(resultNode.getNodeName())) {
                for (String attr : resultList) {
                    if (treeNode.getAttributes().get(attr).getAttrNum() == dataList.size()) {
                        cAttr.setLeafName(attr);
                        return;
                    }
                }
            }
        }
        
//        System.out.println("=_=_=_=_=_=_=datalist==="+dataList);
//        System.out.println("=_=_=_=_=_=_=treelist==="+treeList);
        
        //寻找最优解
        
        //得到根节点
        TreeNode rootNode = treeList.get(0);
        
        for (TreeNode treeNode : treeList) {
            
            if(!treeNode.getNodeName().equals(treeList.get(treeList.size()-1).getNodeName())){
                if(treeNode.getGain() < rootNode.getGain()){
                    rootNode = treeNode;
                }
            }
            
        }
    //    System.out.println("*********↓↓↓↓↓↓↓↓***********当前根节点为："+rootNode.getNodeName()+"***********↓↓↓↓↓↓↓↓*********");
        
        cAttr.setNextNode(rootNode);
        
        //对当前根节点的属性进行遍历，寻找下一个节点
        
        //节点名
        String nodeName = rootNode.getNodeName();
        //属性名
        String attrName = "";
        //属性节点
        Attributes attr = new Attributes();
        //当前节点的属性值集合
        Map<String, Attributes> attrMap = rootNode.getAttributes();
        
        
        //遍历节点的每个属性值
        for (Map.Entry<String, Attributes> entry : attrMap.entrySet()) {
            
            attr = attrMap.get(entry.getKey());
            attrName = attr.getAttrName();
            
            
//            System.out.println("*****************attrName========"+attrName+"******************");
            
            //得到新的data集合对象
            
            List<Map<String, String>> newDataList = new ArrayList<Map<String,String>>();
            Map<String, String> newMap = new HashMap<String, String>();
            //String attrName = rootNode.getAttributes().get("Sunny").getAttrName();
            newMap.clear();
            
            //删除dataList中已处理过的节点数据
            //遍历dataList
            for (Map<String, String> map : dataList) {
                
                if(map.containsKey(nodeName)){
                    
                    if(map.get(nodeName).equals(attrName)){
                        newMap = new HashMap<String, String>();
                        for (Map.Entry<String, String> m : map.entrySet()) {
                            
                            //如果该节点不是已处理过的节点
                            if(!m.getKey().equals(nodeName)){
                                //得到新的节点
                                newMap.put(m.getKey(), map.get(m.getKey()));
                            }
                            
                        }
                        
                        //将新的节点存入newDataList中
                        newDataList.add(newMap);
                    }
                    
                }
                
            } 
//            System.out.println("↓↓↓↓↓↓*******************新的data集合：*******************↓↓↓↓↓↓");
//            for (Map<String, String> map : newDataList) {
//                System.out.println(map);
//            }
            
            //获得新的tree集合对象，而且值为初值
            
            List<TreeNode> newTreeList = new ArrayList<TreeNode>();
            
            //将treeList中的数据清空
            clearTree(treeList);
            
            //删除treeList中已处理过的节点
            for (TreeNode treeNode : treeList) {
                if(!treeNode.getNodeName().equals(nodeName)){
                    newTreeList.add(treeNode);
                }
            }
//            System.out.println("↓↓↓↓↓↓*******************新的tree集合：*******************↓↓↓↓↓↓");
//            for (TreeNode treeNode : newTreeList) {
//                System.out.println(treeNode);
//            }
            
            //递归调用当前函数，继续找节点
            cusTree(newDataList, newTreeList,attr);
        }
    }
    
    /**
     * 输出决策树
     * @param attr
     */
    private void printTree(Attributes attr, String ceil) {
        
        String nodeName = attr.getNextNode().getNodeName();
        Map<String, Attributes> attrMap = attr.getNextNode().getAttributes();
        
        str += ceil+"----"+nodeName+"\r\n";
        for (Map.Entry<String, Attributes> nextAttr : attrMap.entrySet()) {
            
            //如果当前属性值没有下一个节点，则将当前属性值的名称及决策结果输出
            if(attrMap.get(nextAttr.getKey()).getNextNode() == null){
                
                str += ceil+"-------"+attrMap.get(nextAttr.getKey()).getAttrName()+"\r\n";
                str += ceil+"----------"+attrMap.get(nextAttr.getKey()).getLeafName()+"\r\n";
                
            }else{
                
                str += ceil+"-------"+attrMap.get(nextAttr.getKey()).getAttrName()+"\r\n";
                printTree(attrMap.get(nextAttr.getKey()),"------");
            }
        }

    }
    
    /**
     * 打印决策树到txt文本
     * @param path
     */
    private void printTreetoTxt(String path){
        
        if(path == null || path.equals("")) return;
        File file = new File(path);
        File folder = file.getParentFile();
        FileWriter fw;
        try {
            
            if(!folder.exists()){
                folder.mkdirs();
                file.createNewFile();
            }
            
            fw = new FileWriter(file);
            fw.write(str);
            
            fw.flush();
            fw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    
    /**
     * 还原初始数据
     * @param treeList
     */
    private void clearTree(List<TreeNode> treeList){
        
        for (TreeNode treeNode : treeList) {
            Map<String, Attributes> map = treeNode.getAttributes();
            
            for (Map.Entry<String, Attributes> entry : map.entrySet()) {
                Attributes attr = map.get(entry.getKey());
                attr.setAttrNum(0);
                attr.setH(0);
                Map<String, Integer> map2 = attr.getResultNum();
                map2.clear();
            }
            treeNode.setGain(0);
        }
    }
    
}

package com.id3.node;


public class ID3Main {

    public static void main(String[] args) {
        
        ID3Alogo id3Alogo = new ID3Alogo();
        id3Alogo.ID3("决策树名","数据文件地址", "输出文件地址");
        
    }
    
}