C++ TreeNode::addChild方法代码示例

void TreeNode::Tree::copyNode(const AbstractTreeIterator& nodePath, const AbstractTreeIterator& newParentPath)
{
	if (canCopyNodes() == true)
	{
		TreeNode* treeNode = getTreeNodeFromIterator(nodePath);
		TreeNode* newParentNode = getTreeNodeFromIterator(newParentPath);
		if (treeNode != NULL && newParentNode != NULL)
		{
			TreeCloner treeCloner(treeNode, *createNodeFunctor);
			TreeNode* clonedTreeNode = treeCloner.buildTree();
			if (clonedTreeNode != NULL)
			{
				newParentNode->addChild(clonedTreeNode);
				clonedTreeNode->setParent(newParentNode);
			}
			else
			{
				resultError("Can't clone the tree-node to copy!" ERROR_AT);
			}
		}
		else
		{
			argumentError("Need a TreeNode::Iterator to copy a node!" ERROR_AT);
		}
	}
	else
	{
		stateError("Tree can't remove nodes!" ERROR_AT);
	}
}

TreeNode<int>* takeInputLWise() {
	int rootData;
	cout << "Enter root data" << endl;
	cin >> rootData;
	TreeNode<int>* root = new TreeNode<int>(rootData);
	queue<TreeNode<int>*> queue;
	queue.push(root);
	while (!queue.empty()) {
		TreeNode<int>* first = queue.front();
		queue.pop();

		cout << "Enter num children for " << first->getData() << endl;
		int numChild;
		cin >> numChild;
		for (int i = 0; i < numChild; i++) {
			cout << "Enter " << i << "th child of " << first->getData() << endl;
			int childData;
			cin >> childData;
			TreeNode<int>* child = new TreeNode<int>(childData);
			queue.push(child);
			first->addChild(child);
		}
	}
	return root;
}

/*---------------------------------------------------------------------*//**
	ノード配列から作成
		単純な Function 集合メニューを作成する
	
			○ルートノード
			┣●親ノード
			┃┗●子ノード（Fuction）
			┣●親ノード
			┃┗●子ノード（Fuction）
			・
			・
			・
			┗●親ノード
				┗●子ノード（Fuction）
			↑このような形

		また、
		mtnodeParentArrayEntr = NULL, mtnodeChildArrayEntr = NULL,
		numArray = 0 でこの create 実行した後、
		getMenuTreeRootNode でルートノードを得て、
		addMenuTreeNode で要素となるノードを追加する方法もある

	@param	name					名前
	@param	mtnodeParentArrayEntr	親ノード配列（メモリの解放処理は Menu クラス内で行う）
	@param	mtnodeChildArrayEntr	子ノード配列（メモリの解放処理は Menu クラス内で行う）
									# 親ノード配列と同配列数である必要がある
									# 全ての子は Function ノードである必要がある
	@param	numArray				配列長
	@param	functblRef				ファンクションテーブルデータ 
	@param	objParam				パラメータオブジェクト
	@retval	true					成功
	@retval	false					失敗
**//*---------------------------------------------------------------------*/
bool Menu::create(const CStringBase* name, MenuTreeNode** mtnodeParentArrayEntr, MenuTreeNode** mtnodeChildArrayEntr, int numArray, MenuFuncTable* functblRef, MenuPanelFactory* pnlfctryRef, void* objCreateParam)
{
	// ツリーを作成する
	_tree = new Tree<MenuTreeNode>(true);
	
	// 表示対象においての根ノードを作る
	MenuTreeNode* mtnodeRoot = new MenuTreeNode();
	if(!mtnodeRoot->create(name, false, false, false, 0, 0))
	{
		return false;
	}
	
	// ノードを作成する
	TreeNode<MenuTreeNode>* tnode = _tree->addRootNode();
	tnode = tnode->addChild(mtnodeRoot);
	for(int i = 0; i < numArray; i++)
	{
		// 表示される親ノードの追加
		if(i == 0)
		{
			tnode = tnode->addChild(mtnodeParentArrayEntr[i]);
		}
		else
		{
			tnode = tnode->addSibling(mtnodeParentArrayEntr[i]);
		}
		
		// Fuction を提供する子ノードを追加
		tnode->addChild(mtnodeChildArrayEntr[i]);
	}
	
	// ファンクションテーブルを保存する
	_functblRef = functblRef;
	// パネルファクトリを保存する
	_pnlfctryRef = pnlfctryRef;
	// パラメータオブジェクトを保存する
	_objCreateParamRef = objCreateParam;

	// メモリ管理を委譲された配列を削除
	delete[] mtnodeParentArrayEntr;
	delete[] mtnodeChildArrayEntr;
	
	return true;
}

int main() {

	cout << "Initializing Tree with " << 1 << "\n";
	TreeNode *root = new TreeNode(1);
	root->printTree();

	TreeNode *a = root->addChild(2);
	root->printTree();

	TreeNode *b = root->addChild(3);
	root->printTree();

	a->addChild(4);
	root->printTree();

	TreeNode *c = a->addChild(5);
	root->printTree();

	c->addChild(6);
	root->printTree();

	b->addChild(7);
	root->printTree();

	root->breadthSearch();

	root->depthSearch();

	return 0;
}

TreeNode<int>* takeTreeInput() {
	int rootData;
	cout << "Enter root data" << endl;
	cin >> rootData;
	TreeNode<int>* root = new TreeNode<int>(rootData);
	int numChildren;
	cout << "Enter number of children " << endl;
	cin >> numChildren;
	for (int i = 0; i < numChildren; i++) {
		root->addChild(takeTreeInput());
	}
	return root;
}

/*---------------------------------------------------------------------*//**
	ノード追加
**//*---------------------------------------------------------------------*/
bool Menu::addMenuTreeNode(MenuTreeNode* mtnodePos, MenuTreeNode* mtnodeAdd, bool isChild)
{
	TreeNode<MenuTreeNode>* tnodePos = findTreeNodeFromMenuTreeNode(mtnodePos, _tree->getRoot());
	if(tnodePos == 0L)	{	return false;	}

	if(isChild)
	{
		tnodePos->addChild(mtnodeAdd);
	}
	else
	{
		tnodePos->addSibling(mtnodeAdd);
	}
	return true;
}

void TreeNode::Tree::createNode(const AbstractTreeIterator& parentPath, const String& name, bool leaf)
{
	if (canCreateNodes() == true)
	{
		TreeNode* parentNode = getTreeNodeFromIterator(parentPath);
		if (parentNode != NULL)
		{
			TreeNode* newNode = (*createNodeFunctor)(name);
			parentNode->addChild(newNode);
			newNode->setParent(parentNode);
		}
		else
		{
			argumentError("Need a TreeNode::Iterator to create a node!" ERROR_AT);
		}
	}
	else
	{
		stateError("Tree can't create nodes!" ERROR_AT);
	}
}

//.........这里部分代码省略.........
                    }

                    // all features have the same value
                    if(feature_the_same) {
                        temp.setNodeType(AIS);
                        return temp;
                    }

                    // check output
                    set < T2 > output_set;
                    for(size_t ddx = 0; ddx < label_set.size(); ddx++) { // maybe wrong
                        output_set.insert(label_set[ddx]);
                    }

                    // labels are the same
                    if(output_set.size() == 1) {
                        temp.setNodeType(AOS);
                        return temp;
                    }

                    // find maximum information gain
                    temp.setNodeType(MIG);

                    map < T1, int > count_label;
                    for(auto l: label_set) {
                        count_label[l]++;
                    }

                    // H(Y) = - sigma(p(y) * log(p(y))
                    double h_y = 0;
                    for(auto c: count_label) {
                        double p = c.second * 1. / label_set.size();
                        h_y += p * log(p);
                    }
                    h_y = - h_y;

#ifdef DEBUG
                    cerr << "H(Y): " << h_y << endl;
#endif

                    int best_feature = -1;
                    double best_ig = -1.;
                    for(size_t fdx = 0; fdx < selected.size(); fdx++) {
                        if(selected[fdx] == false) {
                            // TODO
                            // IG(Xi) = H(Y) - H(Y|Xi)
                            // H(Y) = - sigma(p(y) * log(p(y))
                            // H(Y|Xi) = sigma(p(xij) * H(Y|xij))
                            // = sigma(p(xij) * [- sigma(p(y|xij) * log(p(y|xij)))]
                            // = -sigma"y, xij"(p(xij, y) * log(p(y|xij)))
                            // = -sigma"y, xij"(p(xij, y) * log(p(xij, y)/p(xij)))
                            map < T1, map < T2, int > > count_value_with_label;
                            for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                                count_value_with_label[feature_set[fdx][ddx]][label_set[ddx]]++;
                            }
                            double h_y_x = 0.;
                            for(auto x: count_value_with_label) {
                                double p_x_with_no_fraction = x.second.size() * 1.;
                                for(auto x_y: x.second) {
                                    double p_x_y_w_n_f = x_y.second * 1. / label_set.size();
                                    h_y_x += p_x_y_w_n_f * log(p_x_y_w_n_f / p_x_with_no_fraction);
                                }
                            }
                            h_y_x = - h_y_x;
                            double ig = h_y - h_y_x;
#ifdef DEBUG
                            cerr << "IG: " << h_y << endl;
#endif
                            if(best_ig < ig) {
                                best_ig = ig;
                                best_feature = fdx;
                            }
                        }
                    }

                    assert(best_feature != -1);
                    // split
                    temp.setFeatureId(best_feature);

                    // choose branches (discrete)
                    set < T1 > values_of_feature;
                    for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                        values_of_feature.insert(feature_set[ddx][best_feature]);
                    }

                    selected[best_feature] = true;
                    for(auto v: values_of_feature) {
                        vector < vector <T1> > children_feature_set;
                        vector < T2 > children_label_set;
                        for(size_t ddx = 0; ddx < label_set.size(); ddx++) {
                            if(feature_set[ddx][best_feature] == v) {
                                children_feature_set.push_back(feature_set[ddx]);
                                children_label_set.push_back(label_set[ddx]);
                            }
                        }
                        temp.addChild(_build(children_feature_set, children_label_set, selected), v);
                    }

                    return temp;
                }