一种常见的数据挖掘的算法SPRINT算法的简单实现

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <math.h>
#include <map>
#include <set>
#include <list>
#include <algorithm>
using namespace std;
map<int,float> xmap;
typedef struct attrelem
{
int attridx;
float attrval;
string classlabel;
int    rid;

attrelem():attridx(0),rid(0){}
};
bool operator==(const attrelem &lhs,const attrelem &rhs)
{
return (lhs.attrval == rhs.attrval && lhs.classlabel == rhs.classlabel
&& lhs.rid == rhs.rid);

}

typedef struct treenode
{
string category;
vector< vector<attrelem> > vecattrlist;
float x;
int splittattridx;
treenode *left;
treenode *right;
treenode():left(NULL),right(NULL),splittattridx(-1){}

}*node_ptr;
float getx(float x1,float x2)
{
return (x1+x2)/2.0;

}
void trimspace(string & str)
{
for (string::iterator it = str.begin(); it != str.end(); it++)
{
if (*it == ' ')
{
it = str.erase(it);
}
}
}
void getsplitstring(string str,char splitter,vector<string> & vecout)
{
size_t pos = str.find_first_of(splitter,0);
size_t beg = 0;
while (pos != string::npos)
{
vecout.push_back(str.substr(beg,pos - beg));
beg = pos + 1;
pos = str.find_first_of(splitter,beg);
}

vecout.push_back(str.substr(beg,str.size() - beg));
}
float square(float x)
{
return x*x;
}
int getisplitter(attrelem *ret,vector< vector<attrelem> > &vecattrlist)
{
int isplitter = -1;
for (int i = 0;i<vecattrlist.size();i++)
{
for (int j = 0;j<vecattrlist[i].size();j++)
{
if (ret == &vecattrlist[i][j])
{
isplitter = i;
break;
}

}
if (isplitter != -1)
break;
}
return isplitter;

}
float getgini(float x,vector<attrelem> & attrlist)
{

vector<string> lessequalval;
vector<string>  greaterlval;
for (int i = 0;i<attrlist.size();i++)
{
if (attrlist[i].attrval<=x)
{
lessequalval.push_back(attrlist[i].classlabel);

}
else
{
greaterlval.push_back(attrlist[i].classlabel);
}
}

map<string,int> catecnt;
for (int i=0;i<lessequalval.size();i++)
{
map<string,int>::iterator it = catecnt.find(lessequalval[i]);
if (it == catecnt.end())
{
catecnt.insert(make_pair(lessequalval[i],0));
catecnt[lessequalval[i]]++;
}
else
{
catecnt[lessequalval[i]]++;
}
}

float lessequalgini = 0.0;
for (map<string,int>::iterator it = catecnt.begin();
it != catecnt.end();it++)
{
lessequalgini = lessequalgini + square((float)it->second/(float)lessequalval.size());
}
lessequalgini = 1 - lessequalgini;

catecnt.clear();
for (int i=0;i<greaterlval.size();i++)
{
map<string,int>::iterator it = catecnt.find(greaterlval[i]);
if (it == catecnt.end())
{
catecnt.insert(make_pair(greaterlval[i],0));
catecnt[greaterlval[i]]++;
}
else
{
catecnt[greaterlval[i]]++;
}
}

float greatergini = 0.0;
for (map<string,int>::iterator it = catecnt.begin();
it != catecnt.end();it++)
{
greatergini = greatergini + square((float)it->second/(float)greaterlval.size());
}
greatergini = 1 - greatergini;

float gini = ((float)lessequalval.size()/(float)attrlist.size()) * lessequalgini + ((float)greaterlval.size()/(float)attrlist.size()) * greatergini;
return gini;

}

int getmingini(vector< vector<attrelem> > &vecattrlist)
{

int isplitter = -1;
float mingini = getgini(getx(vecattrlist[0][0].attrval,vecattrlist[0][1].attrval),vecattrlist[0]);
isplitter = 0;

for (int i = 0;i<vecattrlist.size();i++)
{

for (int j=0;j<vecattrlist[i].size() -1 ;j++)
{
if (vecattrlist[i][j].attrval != vecattrlist[i][j+1].attrval)
{
float x = getx(vecattrlist[i][j].attrval,vecattrlist[i][j+1].attrval);
float gini = getgini(x,vecattrlist[i]);
if (mingini > gini)
{
mingini = gini;
isplitter = i;
xmap[vecattrlist[i][j].attridx] = x;
}
}
}

}
return isplitter;

}
bool isnodepure(vector<attrelem> & attrlist)
{

bool pure = true;
string classlabel = attrlist[0].classlabel;
for (int i = 0;i<attrlist.size();i++)
{
if (classlabel != attrlist[i].classlabel)
{
pure = false;
break;
}

}
return pure;
}

vector< vector<attrelem> >::iterator getit(int isplitter, vector< vector<attrelem> > &vecattrlist)
{

int i=0;
for (vector< vector<attrelem> >::iterator it =vecattrlist.begin();it!=vecattrlist.end();
it++,i++)
{
if (i == isplitter)
return it;
}

}
int splitattrlist(vector< vector<attrelem> > &vecattrlist,vector< vector<attrelem> > &left,vector< vector<attrelem> > &right)
{

int isplitter = getmingini(vecattrlist);
int ret = vecattrlist[isplitter][0].attridx;

while(left.empty() || right.empty() || left[0].empty() || right[0].empty())
{

if (!left.empty() && !right.empty() && (!left[0].empty() || !right[0].empty()) )
{
vecattrlist.erase(getit(isplitter,vecattrlist));

isplitter = getmingini(vecattrlist);
}
left.clear();
right.clear();
for (int i = 0;i<vecattrlist.size();i++)
{
vector<attrelem> attrleft, attrright;
if (i == isplitter)
continue;

float x = xmap[vecattrlist[isplitter][0].attridx];
for (int j = 0;j<vecattrlist[i].size();j++)
{
if (vecattrlist[isplitter][j].attrval <= x /*&& vecattrlist[isplitter][j].rid == vecattrlist[i][j].rid*/)
{
attrleft.push_back(vecattrlist[i][j]);
}
else if (vecattrlist[isplitter][j].attrval > x /*&& vecattrlist[isplitter][j].rid == vecattrlist[i][j].rid*/)
attrright.push_back(vecattrlist[i][j]);
}

left.push_back(attrleft);
right.push_back(attrright);

}
}
return ret;

}

void buildtree(vector< vector<attrelem> > &vecattrlist,node_ptr *tree)
{
if (vecattrlist.size() == 0)
return;
if (isnodepure(vecattrlist[0]))
{
(*tree) = new treenode();
(*tree)->category = vecattrlist[0][0].classlabel;
(*tree)->left = NULL;
(*tree)->right = NULL;
return;

}

vector< vector<attrelem> >left,right;
vector< vector<attrelem> > vecret;

(*tree) = new treenode();
(*tree)->vecattrlist = vecattrlist;
(*tree)->splittattridx = splitattrlist(vecattrlist,left,right);
(*tree)->x = xmap[(*tree)->splittattridx];

buildtree(left,&(*tree)->left);

buildtree(right,&(*tree)->right);

}
bool isvalinlist(float val,vector<float> & vallist)
{
for (int i = 0;i<vallist.size();i++)
{
if (val == vallist[i])
return true;
}
return false;
}
string gettype(vector<string> data,node_ptr tree)
{
if (!tree)
return "";

if (!tree->category.empty())
return tree->category;

float val = atof(data[tree->splittattridx].c_str());

if (val <= tree->x)
{
return gettype(data,tree->left);
}
else
return gettype(data,tree->right);

}

void outputtree(treenode *root,int level)
{
if (!root)
return;
for (int i =0;i<level;i++)
{
cout<<" ";
}

if (root->category.empty())
{
cout<<root->splittattridx+1<<":<"<<root->x<<">"<<endl;
}else
{
cout<<"Class:"<<root->category<<endl;
return;
}
/*cout<<"value:"<<root->leftvalue[0]<<endl;*/
outputtree(root->left,level+1);
/*cout<<"value:"<<root->rightvalue[0]<<endl;*/
outputtree(root->right,level+1);

}
bool lessthan(const attrelem & left,const attrelem & right)
{
if (left.attrval < right.attrval)
return true;
else
return false;
}
int main(int argc, char* argv[])
{
if (argc < 3)
{
cout<<"Usage: "<<argv[0]<<" [filename].test [filename].train"<<endl;
return false;
}

ifstream input(argv[2],ios_base::in);
if (!input)
{
cout<<"Error: open file failed."<<endl;
return false;
}
vector< vector<string> > vectrain;
while (input.peek() != EOF)
{
char oneline[512];
input.getline(oneline,512);
string line = oneline;
trimspace(line);
vector<string> vecout;
getsplitstring(line,',',vecout);
vectrain.push_back(vecout);
}

vector< vector<attrelem> > vecattrlist;
for (int j=0;j<16;j++)
{
vector<attrelem> attrlist;
for (int i = 0;i<vectrain.size();i++)
{
attrelem elem;
elem.attrval = atof(vectrain[i][j].c_str());
elem.classlabel = vectrain[i][16];
elem.rid = i;
elem.attridx = j;
attrlist.push_back(elem);
}
//sort(attrlist.begin(),attrlist.end(),lessthan);
vecattrlist.push_back(attrlist);
}

node_ptr root;

buildtree(vecattrlist,&root);

//outputtree(root,0);
vector< vector<string> > veczoo;

ifstream zooinput(argv[1]);

if (!zooinput)
{
cout<<"Error: open file failed."<<endl;
return false;
}

while (zooinput.peek() != EOF)
{
char oneline[512];
zooinput.getline(oneline,512);
string line = oneline;
trimspace(line);
vector<string> vecout;
getsplitstring(line,',',vecout);

string type = gettype(vecout,root);
cout<<type<<endl;
}
return true;
}