B树 C语言实现

/**
*Data:2011.3.20
*title:base on Branch_board straight selection
*/

#include 
#include 
#include 
using namespace std;

const int D=6;   //总特征数
const int d=2;   //目标特征数
const int inf=100000;   //无穷

int best[D];    //最好结果，舍弃对应位置为0
int max;        //当前最好的结果的可区分性
int q[D-d+1];     //后继节点的个数，即下一层舍去的特征数
int r[D-d+1];     //当前特征集合的基数
vector X;    //当前节点舍弃i个特征后的剩余特征
vector Q;    //当前节点后继舍弃的特征
int l;            //当前层数
int B;            //初始界值
int J[D+1];       //判据值数组
//任意两个特征可区分性
const int cov[6][6]={
		inf13
		3inf5
		67inf
}


class BTree{
public:
    BTree* rchild;    //子节点
    BTree* lchild;    //左兄弟
    BTree* parent;    //父节点
    int        x;    //舍弃的特征
    void generateChild（BTree *）;
};

void sortByJudge（）; //根据判据值进行排序
int  calJudge（vector &Q int x）; //计算当前节点判据值
void backUp（BTree *root）;  //回溯
void updatePath（BTree *root）;
void addUnion（vector &srcint n）;  //集合相加
void subUnion（vector &fir vector &sec）;  //集合相减
void subUnion（vector &srcint n）;      //重载上一个函数
void search（BTree *root）;   //搜索解
//void updateUnion（）; //更新集合
void freeMem（BTree *root）;
void printResult（）; //输出结果

void BTree::generateChild（BTree *root）{
    BTree *node=new BTree（）;
    root->rchild=node;
    node->parent=root;
    node->x=Q[q[l]-1];

    for（int i=1;i        BTree *node2;
        //注意最左结点
        if（i=q[l]-1）{
            node->lchild=NULL;
        }
        else{
            node2=new BTree（）;
            node->rchild=NULL;
            node->lchild=node2;
            node2->parent=node;
            node2->x=Q[q[l]-i-1];
            node=node2;
        }
    }
    //更新 XQ
    sortByJudge（X）;
    Q.clear（）;
    //May be a bug.
    copy（X.begin（）X.begin（）+q[l]back_inserter（Q））;
    //计算J表
    for（int i=0;i    for（int i=0;i        J[X[i]=calJudge（XX[i]）;
    }
    subUnion（XQ）;  //更新集合X
}

void init（）{
    //初始化r和d
    r[0]=D;r[D-d]=0;
    for（int i=0;i    for（int i=0;i        q[i]=r[i]-（D-d-i-1）;
        r[i+1]=r[i]-q[i];
    }
    B=0;
}

void search（BTree *root）{
    l=0;
    while（l>=0）{
        q[l]=r[l]-（D-d-l-1）;
        sortByJudge（）;  //排序并更新集合X
        //判断下一层是否到达叶结点，更新界值
        if（l+1==D-d）{
            if（J[q[l]-1]>B）{
                B=J[q[l]-1];
                updatePath（root->