数据挖掘算法实现

学习了数据挖掘这门课，但是里面的算法仅仅是稍微了解了一下，并没有实现一下，试着把每个算法实现一下。。。。

1、决策树之ID3

下表记录了在不同气候条件下是否去打球的情况，要求根据该表用程序输出决策树。

Day Outlook Temperature Humidity Wind PlayTennis
1 Sunny Hot High Weak no
2 Sunny Hot High Strong no
3 Overcast Hot High Weak yes
4 Rainy Mild High Weak yes
5 Rainy Cool Normal Weak yes
6 Rainy Cool Normal Strong no
7 Overcast Cool Normal Strong yes
8 Sunny Mild High Weak no
9 Sunny Cool Normal Weak yes
10 Rainy Mild Normal Weak yes
11 Sunny Mild Normal Strong yes
12 Overcast Mild High Strong yes
13 Overcast Hot Normal Weak yes
14 Rainy Mild High Strong no
end

下面是ID3的部分程序，还没有写完，慢慢再补。

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cmath>

using namespace std;

class Node
{
public:
    vector<int> next;
    string attr;
    string ans;
    //Node() next(), attr(""), ans(""){}
};

const string yes = "yes";
const string no = "no";
const int attribute_name_size = 6;
vector< vector<string> > data; //day weather temperature humidity wind play_or_not
Node node[1000];
int cnt_of_node = 0;

void input()
{
    string str;
    vector<string> tmp;
    while (cin >> str && str != "end")
    {
        tmp.push_back(str);
        for (int i = 0; i < attribute_name_size-1; ++i)
        {
            cin >> str;
            tmp.push_back(str);            
        }
        data.push_back(tmp);
        tmp.clear();
    }
}

double calcEntropy(vector<vector<string> >& vec, string element)
{
    double ans = 0;    
    map<string, int> mp;
    if (vec.size() <= 0) return -1;
    for (int j = 0; j < vec[0].size(); ++j)
    {
        if (vec[0][j] == element)
            for (int i = 1; i < vec.size(); ++i)
                mp[vec[i][j]]++;            
    }
    double cnt = vec.size()-1;
    for (map<string, int>::iterator it = mp.begin(); it != mp.end(); ++it)
    {
        double p = (it->second)/cnt;
        ans -= p*log2(p);
    }
    return ans;
}

double calcInfo(vector<vector<string> >& vec, int idx)
{
    double ans = 0;
    if (vec.size() <= 1) return -1;
    map<string, map<string, int> > mp;
    int len = vec[0].size();
    int size = vec.size()-1;

    for (int j = 1; j < vec.size(); ++j)
        mp[vec[j][idx]][vec[j][len-1]]++;
    for (map<string, map<string, int> >::iterator it = mp.begin(); it != mp.end(); ++it)
    {
        int ys = 0, nt = 0;
        for (map<string, int>::iterator itr = (it->second).begin(); itr != (it->second).end(); ++itr)
        {
            if (itr->first == yes) ys += itr->second;
            if (itr->first == no) nt += itr->second;            
        }
        ans = -(ys+nt)/size*(-ys/(ys+nt)*log2(ys/(ys+nt)) - nt/(ys+nt)*log2(nt/(ys+nt)));
    }
    return ans;
}

int findBestAttribute(vector<vector<string> >& tmp)
{
    if (tmp.size() <= 1) return -1;
    int len = tmp[0].size();
    string result = tmp[0][len-1];
    vector<double> v;
    double info_result = calcEntropy(tmp, result);
    for (int i = 0; i < len; ++i)
        v.push_back(calcInfo(tmp, i));
    double max_info_gain = 0;
    int idx = 0;
    for (int i = 0; i < v.size(); ++i)
    {
        if (info_result-v[i] > max_info_gain)
            max_info_gain = info_result-v[idx=i];
    }
    return idx;
}

void work(vector< vector<string> >& source, int now_node_num)
{
    int idx = 0;
    idx = findBestAttribute(source);
    vector<int> vis(source.size(), 0);
    vector<string> attribute_tmp;
    for (int i = 0; i < source[0].size(); ++i)
        if (i != idx) attribute_tmp.push_back(source[0][i]);
    int len = source[0].size();
    for (int i = 1; i < source.size(); ++i)
    {
        if (vis[i]) continue;
        map<string, int> mp;
        for (int j = i; j < source.size(); ++j)
        {
            if (source[j][idx] == source[i][idx])
            {
                mp[source[j][len-1]]++;
                vis[j] = 1;
            }
        }
        node[now_node_num].next.push_back(++cnt_of_node);
        node[cnt_of_node].attr = source[i][idx];
        if (mp.size() == 1)
        {
            node[cnt_of_node].ans = source[i][len-1];    
            node[cnt_of_node].next.clear();
        }
        else
        {
            vector<vector<string> > vs;
            for (int j = 0; j < source.size(); ++j)
            {
                vector<string> tmp;
                for (int k = 0; k < source[0].size(); ++k)
                {
                    if (k == idx) continue;
                    tmp.push_back(source[j][k]);    
                }
                vs.push_back(tmp);
            }
            work(vs, cnt_of_node);
        }
    }
}

void outputSourceData()
{
    for (int i = 0; i < data.size(); ++i)
    {
        for (int j = 0; j < data[i].size(); ++j)
            cout << data[i][j] << '	';
        cout << endl;
    }
}

int main()
{
        
    return 0;
}