├── main.cpp
├── input.txt
├── README.md
├── .gitattributes
├── .gitignore
└── DecisionTree.h


/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include"DecisionTree.h"
 3 | using namespace std;
 4 | int main(){    
 5 |     Tree* tree=new Tree;
 6 |     cout<<"Trained..........."<<endl;
 7 | 
 8 |     while(1)
 9 |     tree->GetOutPut();
10 | 
11 |     return 0;
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/input.txt:
--------------------------------------------------------------------------------
 1 | 3 0
 2 | 3 0
 3 | 2 0
 4 | 2 1
 5 | 0 0 0 0 0 0
 6 | 0 0 0 1 0 0
 7 | 1 0 0 0 1 0
 8 | 2 1 0 0 1 0
 9 | 2 2 1 0 1 0
10 | 2 2 1 1 0 0
11 | 1 2 1 1 1 0
12 | 0 1 0 0 0 0
13 | 0 2 1 0 1 0
14 | 2 1 1 0 1 0
15 | 0 1 1 1 1 0
16 | 1 1 0 1 1 0
17 | 1 0 1 0 1 0
18 | 2 1 0 1 0 1
19 | 
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DecisionTree
 2 | # The realization of decision tree learning algorithm-----C++ Version，决策树学习算法，C++实现
 3 | 
 4 | # 代码中有详细注释
 5 | # 此决策树采用最普通的ID3算法
 6 | 
 7 | 
 8 | 输入格式
 9 | 先输入分类属性的数量
10 | 再输入训练样例，比如有如下属性和训练样例
11 | 
12 | 年龄：幼儿，儿童，少年，青年，中年，老年
13 | 压力：小，中，大
14 | 是否幸福：不幸福，普通，很幸福
15 | 
16 | 样例：
17 | 1.幼儿 小 很幸福
18 | 2.儿童 中 普通
19 | 3.少年 中 不幸福
20 | 
21 | 则对应的输入为
22 | 6 0
23 | 3 0
24 | 3 1
25 | 0 0 2 0
26 | 1 1 1 0
27 | 2 1 0 1
28 | 
29 | 项目中有一个简单的训练样例
30 | 
31 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Windows image file caches
 2 | Thumbs.db
 3 | ehthumbs.db
 4 | 
 5 | # Folder config file
 6 | Desktop.ini
 7 | 
 8 | # Recycle Bin used on file shares
 9 | $RECYCLE.BIN/
10 | 
11 | # Windows Installer files
12 | *.cab
13 | *.msi
14 | *.msm
15 | *.msp
16 | 
17 | # Windows shortcuts
18 | *.lnk
19 | 
20 | # =========================
21 | # Operating System Files
22 | # =========================
23 | 
24 | # OSX
25 | # =========================
26 | 
27 | .DS_Store
28 | .AppleDouble
29 | .LSOverride
30 | 
31 | # Thumbnails
32 | ._*
33 | 
34 | # Files that might appear on external disk
35 | .Spotlight-V100
36 | .Trashes
37 | 
38 | # Directories potentially created on remote AFP share
39 | .AppleDB
40 | .AppleDesktop
41 | Network Trash Folder
42 | Temporary Items
43 | .apdisk
44 | 


--------------------------------------------------------------------------------
/DecisionTree.h:
--------------------------------------------------------------------------------
  1 | #ifndef DECISIONTREE
  2 | #define DECISIONTREE
  3 | #include<vector>
  4 | #include<math.h>
  5 | using namespace std;
  6 | 
  7 | //训练用数据
  8 | class TrainData{
  9 | public:
 10 |     vector<vector<int> > Input;//一行一条数据
 11 |     vector<int> OutPut;//允许离散的输出值
 12 |     void InSertData(vector<int> data,int out){//输入一行数据和目标输出
 13 |         Input.push_back(data);
 14 |         OutPut.push_back(out);
 15 |     }
 16 | };
 17 | 
 18 | class Node{
 19 | public:
 20 |     int Attribute;//属性序号
 21 |     bool IsLeaf;//是否是叶节点
 22 |     vector<Node*> Num;//子女节点
 23 |     Node(int ID,bool a):Attribute(ID),IsLeaf(a){}
 24 | 
 25 | };
 26 | 
 27 | //决策树
 28 | class Tree{
 29 | private:
 30 |     Node* Root;//根节点
 31 | 
 32 |     vector<vector<int> > AttrData;//属性列表
 33 | 
 34 |     Node* CreateTree(TrainData data,vector<int> usedAttr);//ID3算法生成树
 35 |     int MostNormalOutPut(TrainData data);//将最普遍的输出作为节点值
 36 |     int Best(TrainData data,vector<int> usedAttr);//计算信息增益最高的属性
 37 |     double Entropy(TrainData data);//计算信息熵
 38 | public:
 39 |     Tree();
 40 |     void GetOutPut();//输入一个案例，获得输出
 41 | };
 42 | 
 43 | Tree::Tree(){
 44 |     /*输入属性列表，输入每个属性的分类属性个数即可*/
 45 |     int stop=0,num=0;
 46 |     while(!stop){
 47 |         vector<int> temp;
 48 |         cout<<"Attribute"<<"["<<num<<"]"<<":";
 49 |         int aa;
 50 |         cin>>aa;
 51 |         for(int i=0;i<aa;i++)
 52 |             temp.push_back(i);
 53 |         AttrData.push_back(temp);
 54 |         cout<<"Stop?"<<endl;
 55 |         cin>>stop;
 56 |         num++;
 57 |     }
 58 | 
 59 |     /*输入训练数据，直接按顺序输入分类属性序号*/
 60 |     TrainData data;
 61 |     stop=0;
 62 |     while(!stop){
 63 |         vector<int> train;
 64 |         cout<<"TrainData:";
 65 |         int aa=0;
 66 |         for(unsigned int i=0;i<AttrData.size();i++){
 67 |             cin>>aa;
 68 |             train.push_back(aa);
 69 |         }
 70 |         cout<<"OutPut:";
 71 |         int aaa;
 72 |         cin>>aaa;
 73 |         data.InSertData(train,aaa);
 74 |         cout<<"Stop?"<<endl;
 75 |         cin>>stop;
 76 |     }
 77 | 
 78 |     vector<int> temp2;
 79 |     Root=CreateTree(data,temp2);
 80 |     cout<<"Training........."<<endl;
 81 | }
 82 | 
 83 | Node* Tree::CreateTree(TrainData data,vector<int> usedAttr){
 84 | 
 85 |     Node* root=new Node(0,0);//创建根节点
 86 | 
 87 |     /*如果输出都一样，则创建一个节点，值为该输出，且为叶节点*/
 88 |     int stop=1;
 89 |     for(unsigned int i=1;i<data.OutPut.size();i++){
 90 |         if(data.OutPut[i]!=data.OutPut[i-1])
 91 |             stop=0;
 92 |     }
 93 |     if(stop)
 94 |         return new Node(data.OutPut[0],1);
 95 | 
 96 |     /*如果所有属性都用过，那么返回的节点的值为最普遍的输出，且为叶节点*/
 97 |     if(usedAttr.size()==AttrData.size())
 98 |         return new Node(MostNormalOutPut(data),1);
 99 | 
100 |     /*选出信息增益最高的属性作为节点*/
101 |     int A=Best(data,usedAttr);
102 |     usedAttr.push_back(A);//加入已使用属性
103 |     root->Attribute=A;
104 | 
105 |     /*递归的在每一个分类属性下新建一棵树*/
106 |     for(unsigned int i=0;i<AttrData[A].size();i++){
107 |         TrainData tempExample;
108 |         for(unsigned int j=0;j<data.OutPut.size();j++){
109 |             if(i==data.Input[j][A]){
110 |                 tempExample.InSertData(data.Input[j],data.OutPut[j]);
111 |             }
112 |         }
113 |         if(tempExample.OutPut.empty()){
114 |             root->Num.push_back(new Node(MostNormalOutPut(data),1));
115 |         }
116 |         else{
117 |             root->Num.push_back(CreateTree(tempExample,usedAttr));
118 |         }
119 |     }
120 | 
121 |     return root;
122 | }
123 | 
124 | int Tree::MostNormalOutPut(TrainData data){
125 |     vector<int> out;//记录输出的种类
126 |     vector<int> count;//记录种类的数量
127 |     for(unsigned int i=0;i<data.OutPut.size();i++){
128 |         bool ex=0;
129 |         int index=0;
130 |         for(unsigned int j=0;j<out.size();j++){
131 |             if(out[j]==data.OutPut[i]){
132 |                 ex=1;
133 |                 index=j;
134 |             }
135 |         }
136 |         if(ex){
137 |             count[index]++;
138 |         }
139 |         else{
140 |             out.push_back(data.OutPut[i]);
141 |             count.push_back(1);
142 |         }
143 |     }
144 |     /*计算数量最多的种类*/
145 |     int maxi=0;
146 |     int max=0;
147 |     for(unsigned int i=0;i<count.size();i++){
148 |         if(count[i]>max){
149 |             maxi=i;
150 |             max=count[i];
151 |         }
152 |     }
153 |     return out[maxi];
154 | }
155 | 
156 | double Tree::Entropy(TrainData data){
157 |     /*计算输出种类和数量*/
158 |     vector<double> out;
159 |     vector<double> count;
160 |     for(unsigned int i=0;i<data.OutPut.size();i++){
161 |         bool ex=0;
162 |         int index=0;
163 |         for(unsigned int j=0;j<out.size();j++){
164 |             if(out[j]==data.OutPut[i]){
165 |                 ex=1;
166 |                 index=j;
167 |             }
168 |         }
169 |         if(ex){
170 |             count[index]++;
171 |         }
172 |         else{
173 |             out.push_back(data.OutPut[i]);
174 |             count.push_back(1);
175 |         }
176 |     }
177 |      /*计算信息熵*/
178 |     double total=0;
179 |     for(unsigned int i=0;i<count.size();i++)
180 |         total+=count[i];
181 |     double sum=0;
182 |     for(unsigned int i=0;i<count.size();i++){
183 |         double a=0;
184 |         if((count[i]/total)!=0)
185 |             a=log2((count[i]/total));
186 |         sum-=(count[i]/total)*a;
187 |     }
188 |     return sum;
189 | }
190 | 
191 | int Tree::Best(TrainData data,vector<int> usedAttr){
192 |     vector<double>  Gain;//记录每一个属性的信息增益
193 | 
194 |     bool used;
195 |     /*将使用过的属性的信息增益设置为0*/
196 |     for(unsigned int i=0;i<AttrData.size();i++){
197 |         used=0;
198 |         for(unsigned int k=0;k<usedAttr.size();k++)
199 |             if(i==usedAttr[k]){
200 |                 Gain.push_back(0.0);
201 |                 used=1;
202 |             }
203 |         if(used)
204 |             continue;
205 |         /*计算信息增益*/
206 |         else{
207 |             double es=Entropy(data);
208 |             for(unsigned int j=0;j<AttrData[i].size();j++){
209 |                 TrainData tempData;
210 |                 for(unsigned int k=0;k<data.Input.size();k++){
211 |                     if(j==data.Input[k][i]){
212 |                         tempData.InSertData(data.Input[k],data.OutPut[k]);
213 |                     }
214 |                 }
215 |                 if(!tempData.Input.empty()){
216 |                     es-=(double(tempData.Input.size())/double(data.Input.size()))*Entropy(tempData);
217 |                 }
218 |             }
219 |             Gain.push_back(es);
220 |         }
221 |     }
222 | 
223 |     /*计算信息增益最高的属性*/
224 |     int maxi=0;
225 |     double max=0;
226 |     for(unsigned int i=0;i<Gain.size();i++){
227 |         if(Gain[i]>max){
228 |             maxi=i;
229 |             max=Gain[i];
230 |         }
231 |     }
232 |     return maxi;
233 | }
234 | 
235 | void Tree::GetOutPut(){
236 |     vector<int> data;
237 |     cout<<"TestData:";
238 |     int aa=0;
239 |     for(int i=0;i<AttrData.size();i++){
240 |         cin>>aa;
241 |         data.push_back(aa);
242 |     }
243 |     if(Root->IsLeaf){
244 |         cout<<"OutPut:"<<Root->Attribute<<endl;
245 |         return;
246 |     }
247 |     Node* current=Root->Num[data[Root->Attribute]];
248 |     while(!current->IsLeaf)
249 |         current=current->Num[data[current->Attribute]];
250 |     cout<<"OutPut:"<<current->Attribute<<endl;
251 | }
252 | 
253 | #endif // PAIR
254 | 


--------------------------------------------------------------------------------