問題描述：這裡有17個屬性，背景是美國選舉，然後我們需要做的就是根據除了Class Name的16個屬性判斷這個人是哪個黨派。

std::string temp[17] = { "Class Name", "handicapped-infants", "water-project-cost-sharing",
"adoption-of-the-budget-resolution", "physician-fee-freeze",
"el-salvador-aid", "religious-groups-in-schools", "anti-satellite-test-ban",
"aid-to-nicaraguan-contras", "mx-missile", "immigration", "synfuels-corporation-cutback",
"education-spending", "superfund-right-to-use", "crime", "duty-free-exports",
"export-administration-act-south-africa" };

以下是原始碼:

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <cmath>
using namespace std;
#define MAXLEN 17//輸入每行的資料個數

//多叉樹的實現 
//每個結點的所有孩子用vector儲存
//資料結構的設計很重要，本演算法採用5比較合適，同時
//注意維護剩餘樣例和剩餘屬性資訊，建樹時橫向遍歷考迴圈屬性的值，
//縱向遍歷靠遞迴呼叫

vector <vector <string> > state;    //訓練例項
vector <vector <string>> teststate;  //測試例項
vector <string> item(MAXLEN);//對應一行例項集
vector <string> attribute_row;//儲存首行即屬性行資料
string blank("");
map<string, vector < string > > map_attribute_values;//儲存屬性對應的所有的值
int tree_size = 0;
struct Node{//決策樹節點
	string attribute;//屬性值
	string arrived_value;//到達的屬性值
	vector<Node *> childs;//所有的孩子
	Node(){
		attribute = blank;
		arrived_value = blank;
	}
};
Node * root;

//根據資料例項計算屬性與值組成的map
void ComputeMap(){
	unsigned int i, j, k;
	bool exited = false;
	vector<string> values;
	for (i = 0; i < MAXLEN ; i++){//按照列遍歷
		for (j = 0; j < state.size(); j++){
			for (k = 0; k < values.size(); k++){
				if (!values[k].compare(state[j][i])) exited = true;
			}
			if (!exited){
				values.push_back(state[j][i]);//注意Vector的插入都是從前面插入的，注意更新it，始終指向vector頭
			}
			exited = false;
		}
		map_attribute_values[attribute_row[i]] = values;
		values.erase(values.begin(), values.end());
	}
}

//根據具體屬性和值來計算熵
double ComputeEntropy(vector <vector <string> > remain_state, string attribute, string value, bool ifparent){
	//vector<int> count(2, 0);
	int count[2] = { 0 };
	unsigned int i, j;
	bool done_flag = false;//哨兵值
	for (j = 1; j < MAXLEN; j++){
		if (done_flag) break;
		if (!attribute_row[j].compare(attribute)){
			for (i = 1; i < remain_state.size(); i++){
				if ((!ifparent&&!remain_state[i][j].compare(value)) || ifparent){//ifparent記錄是否算父節點
					if (!remain_state[i][0].compare("republican")){
						count[0]++;
					}
					else count[1]++;
				}
			}
			done_flag = true;
		}
	}
	if (count[0] == 0 || count[1] == 0) return 0;//全部是正例項或者負例項
	//具體計算熵 根據[+count[0],-count[1]],log2為底通過換底公式換成自然數底數
	double sum = count[0] + count[1];
	double entropy = -count[0] / sum*log(count[0] / sum) / log(2.0) - count[1] / sum*log(count[1] / sum) / log(2.0);
	return entropy;
}

//計算按照屬性attribute劃分當前剩餘例項的資訊增益
double ComputeGain(vector <vector <string> > remain_state, string attribute){
	unsigned int j, k, m;
	//首先求不做劃分時的熵
	double parent_entropy = ComputeEntropy(remain_state, attribute, blank, true);
	double children_entropy = 0;
	//然後求做劃分後各個值的熵
	vector<string> values = map_attribute_values[attribute];
	vector<double> ratio;
	vector<int> count_values;
	int tempint;
	for (m = 0; m < values.size(); m++){
		tempint = 0;
		for (k = 1; k < MAXLEN ; k++){
			if (!attribute_row[k].compare(attribute)){
				for (j = 0; j < remain_state.size(); j++){
					if (!remain_state[j][k].compare(values[m])){
						tempint++;
					}
				}
			}
		}
		count_values.push_back(tempint);
	}

	for (j = 0; j < values.size(); j++){
		ratio.push_back((double)count_values[j] / (double)(remain_state.size() - 1));
	}
	double temp_entropy;
	for (j = 0; j < values.size(); j++){
		temp_entropy = ComputeEntropy(remain_state, attribute, values[j], false);
		children_entropy += ratio[j] * temp_entropy;
	}
	return (parent_entropy - children_entropy);
}

int FindAttriNumByName(string attri){
	for (int i = 0; i < MAXLEN; i++){
		if (attribute_row[i]==attri) return i;
	}
	cerr << "can't find the numth of attribute" << endl;
	return 0;
}

//找出樣例中佔多數的黨派
string MostCommonLabel(vector <vector <string> > remain_state){
	int p = 0, n = 0;
	for (unsigned i = 0; i < remain_state.size(); i++){
		if (!remain_state[i][0].compare("republican")) p++;
		else n++;
	}
	if (p >= n) return "republican";
	else return "democrat";
}

//判斷樣例是否為同一個黨派
bool AllTheSameLabel(vector <vector <string> > remain_state, string label){
	int count = 0;
	bool mark = false;
	for (unsigned int i = 0; i < remain_state.size(); i++){
		if (!remain_state[i][0].compare(label)) count++;
	}
	if (count == remain_state.size() - 1) return true;
	else return false;
}

//計算資訊增益，DFS構建決策樹
//current_node為當前的節點
//remain_state為剩餘待分類的樣例
//remian_attribute為剩餘還沒有考慮的屬性
//返回根結點指標
Node * BulidDecisionTreeDFS(Node * p, vector <vector <string> > remain_state, vector <string> remain_attribute){
	if (p == NULL)
		p = new Node();
	//先看搜尋到樹葉的情況
	if (AllTheSameLabel(remain_state, "republican")){
		p->attribute = "republican";
		return p;
	}
	if (AllTheSameLabel(remain_state, "democrat")){
		p->attribute = "democrat";
		return p;
	}
	if (remain_attribute.size() == 0){//所有的屬性均已經考慮完了,結果中還是有兩個黨派
		string label = MostCommonLabel(remain_state);
		p->attribute = label;
		return p;
	}

	double max_gain = 0, temp_gain;
	vector <string>::iterator max_it = remain_attribute.begin();
	vector <string>::iterator it1;
	for (it1 = remain_attribute.begin(); it1 < remain_attribute.end(); it1++){
		temp_gain = ComputeGain(remain_state, (*it1));
		if (temp_gain > max_gain) {
			max_gain = temp_gain;
			max_it = it1;
		}
	}
	//下面根據max_it指向的屬性來劃分當前樣例，更新樣例集和屬性集
	vector <string> new_attribute;
	vector <vector <string> > new_state;
	for (vector <string>::iterator it2 = remain_attribute.begin(); it2 < remain_attribute.end(); it2++){
		if ((*it2).compare(*max_it)) new_attribute.push_back(*it2);
	}
	//確定了最佳劃分屬性，儲存
	p->attribute = *max_it;
	vector <string> values = map_attribute_values[*max_it];
	int attribue_num = FindAttriNumByName(*max_it);
	new_state.push_back(attribute_row);
	for (vector <string>::iterator it3 = values.begin(); it3 < values.end(); it3++){
		for (unsigned int i = 0; i < remain_state.size(); i++){
			if (!remain_state[i][attribue_num].compare(*it3)){
				new_state.push_back(remain_state[i]);
			}
		}
		Node * new_node = new Node();
		new_node->arrived_value = *it3;
		if (new_state.size() == 0){//表示當前沒有這個分支的樣例，當前的new_node為葉子節點
			new_node->attribute = MostCommonLabel(remain_state);
		}
		else
			BulidDecisionTreeDFS(new_node, new_state, new_attribute);
		//遞迴函式返回時即回溯時需要 將新結點加入父節點孩子容器  清除new_state容器
		p->childs.push_back(new_node);
		new_state.erase(new_state.begin() + 1, new_state.end());//注意先清空new_state中的前一個取值的樣例，準備遍歷下一個取值樣例
	}
	return p;
}


void Input(){
	std::fstream in("train.txt", std::fstream::in | std::fstream::out);
	int lines = 0;
	while (!in.eof()) {
		std::vector<std::string> temp(17);
		std::string buffer;
		int begin_sign = 0;
		int len;
		in >> buffer;
		int i1 = 0;
		for (int i = 0; i <= buffer.length(); i++) {
			if (i == buffer.length() || buffer[i] == ',') {
				temp[i1] = buffer.substr(begin_sign, i - begin_sign);
				begin_sign = i + 1;
				++i1;
			}
		}
		lines++;
		if (temp[0] != "") {
			state.push_back(temp);
		}
	}
	cout << lines << endl;
}
bool Judge(Node* root, vector <string> teststate){
	if (!root){ cout << "error tree!"; exit(0); }
	bool istrue = false;
	for (vector<Node*>::iterator it = root->childs.begin(); it != root->childs.end(); it++){         //遍歷子節點
		if (((*it)->attribute == "republican" || (*it)->attribute == "democrat")){                  //如果這個節點是葉子節點，即黨派
			int num = FindAttriNumByName(root->attribute);
			if ((*it)->attribute == teststate[0] && (*it)->arrived_value==teststate[num]) {         
				istrue = true;
				return true;
			}
		}
		int sub = FindAttriNumByName(root->attribute);                                          //非葉子節點，根據到達值繼續搜尋
		if ((*it)->arrived_value == teststate[sub]){
			return	Judge(*it, teststate);
		}
	}
	return istrue;
}


double Inputtest(Node* root){
	std::fstream in("test.txt", std::fstream::in | std::fstream::out);
	int lines = 0;
	while (!in.eof()) {
		std::vector<std::string> temp(17);
		std::string buffer;
		int begin_sign = 0;
		int len;
		in >> buffer;
		int i1 = 0;
		for (int i = 0; i <= buffer.length(); i++) {
			if (i == buffer.length() || buffer[i] == ',') {
				temp[i1] = buffer.substr(begin_sign, i - begin_sign);
				begin_sign = i + 1;
				++i1;
			}
		}
		lines++;
		if (temp[0] != "") {
			teststate.push_back(temp);
		}
	}
	int count = 0;
	cout << lines << endl;
	for (int a = 0; a < lines; a++){
		if (Judge(root, teststate[a]))
			count++;
	}
	return count*1.0 / lines*1.0;
    
}

void PrintTree(Node *p, int depth){
	for (int i = 0; i < depth; i++) cout << '\t';//按照樹的深度先輸出tab
	if (!p->arrived_value.empty()){
		cout << p->arrived_value << endl;
		for (int i = 0; i < depth + 1; i++) cout << '\t';//按照樹的深度先輸出tab
	}
	cout << p->attribute << endl;
	for (vector<Node*>::iterator it = p->childs.begin(); it != p->childs.end(); it++){
		PrintTree(*it, depth + 1);
	}
}


void Treesize(Node *p){
	if (p == NULL)
		return;
	for (vector<Node*>::iterator it = p->childs.begin(); it != p->childs.end(); it++){
		Treesize(*it);
	}
	tree_size++;
}

int main(){
	Input();
	vector <string> remain_attribute;
	std::string temp[17] = { "Class Name", "handicapped-infants", "water-project-cost-sharing",
		"adoption-of-the-budget-resolution", "physician-fee-freeze",
		"el-salvador-aid", "religious-groups-in-schools", "anti-satellite-test-ban",
		"aid-to-nicaraguan-contras", "mx-missile", "immigration", "synfuels-corporation-cutback",
		"education-spending", "superfund-right-to-use", "crime", "duty-free-exports",
		"export-administration-act-south-africa" };
	for (int a = 0; a < 17; a++){
		attribute_row.push_back(temp[a]);
		
	}
	for (int a = 1; a < 17; a++){
		remain_attribute.push_back(temp[a]);
	}

	vector <vector <string> > remain_state;
	for (unsigned int i = 0; i < state.size(); i++){
		remain_state.push_back(state[i]);
	}
	ComputeMap();
	root = BulidDecisionTreeDFS(root, remain_state, remain_attribute);
	cout << "the decision tree is :" << endl;
	PrintTree(root, 0);
	Treesize(root);
	cout << endl;
	cout << "tree_size:" << tree_size << endl;
	cout<<"正確率"<<Inputtest(root)*100<<"%"<<endl;
	return 0;
}