void ClearTree(CBTType * treeNode)
{
if(treeNode)
{
ClearTree(treeNode->left); //清空左子树
ClearTree(treeNode->right); //清空右子树
free(treeNode); //释放当前节点所占内存
treeNode = NULL;
}
}
void ClearTree(treeNode** root)
{
if(! *root)
{ return; }
if(!(*root)->lTree && !(*root)->rTree)
{
free(*root);
return ;
}
ClearTree(&(*root) -> lTree);
ClearTree(&(*root) -> rTree);
free(*root);
return ;
}
int KUiShowWndTree::BuildTree(IIniFile *pIni)
{
int nResult = FALSE;
KG_PROCESS_ERROR(pIni);
char szUnit[128] = "";
char szNextUnit[128] = "";
char szParentName[128] = "";
char szKeyValue[128] = "";
BOOL bHasRootWnd = FALSE;
while (pIni->GetNextSection(szUnit, szNextUnit))
{
pIni->GetString(szNextUnit, "._WndType", "", szKeyValue, sizeof(szKeyValue));
if (_tcsicmp(szKeyValue, g_GetWndTypeKey(UI_WND_FRAME)) == 0)
{
pIni->GetString(szNextUnit, "._Parent", "", szParentName, sizeof(szParentName));
_ASSERT(g_IsStringFrameLayer(szParentName));
bHasRootWnd = TRUE;
break;
}
strcpy(szUnit, szNextUnit);
}
KG_PROCESS_ERROR(bHasRootWnd);
ClearTree();
ZeroMemory(&m_Root, sizeof(m_Root));
strcpy(m_Root.szName, szNextUnit);
strcpy(m_Root.szParentName, szParentName);
szUnit[0] = 0;
szNextUnit[0] = 0;
while (pIni->GetNextSection(szUnit, szNextUnit))
{
if (!strcmp(szNextUnit, m_Root.szName))
{
strcpy(szUnit, szNextUnit);
continue;
}
AddNodeByName(pIni, szNextUnit);
strcpy(szUnit, szNextUnit);
}
nResult = TRUE;
Exit0:
return nResult;
}
void QCSTreeWidget::UpdateTree()
{
ClearTree();
for (size_t i=0;i<clCS->GetQtyProperties();++i)
{
QString str;
CSProperties* prop=clCS->GetProperty(i);
if (prop==NULL) break;
AddPropItem(prop);
}
std::vector<CSPrimitives*> vPrims = clCS->GetAllPrimitives();
for (size_t i=0;i<vPrims.size();++i)
AddPrimItem(vPrims.at(i));
}
int main()
{
int totalNodesInTree, inFixArr[15],preFixArr[15],nodeToBeDeleted;
treeNode *root = NULL;
printf("\nEnter length of arr : ");
scanf("%d",&totalNodesInTree);
printf("\nEnter values of nodes in preorder\n");
scanArr(preFixArr,totalNodesInTree);
printArr(preFixArr,totalNodesInTree);
printf("\nEnter values of nodes in inorder\n");
scanArr(inFixArr,totalNodesInTree);
printArr(inFixArr,totalNodesInTree);
printf("\n\nPost Fix Order as shown :\n");
root = toPostFix(inFixArr,preFixArr,0,totalNodesInTree-1,0);
printf("\n");
printf("after creating tree :- \n");
printf("\nPrefix Notation\n");
prefix(root);
printf("\nInfix Notation\n");
infix(root);
printf("\nPostfix Notation\n");
postfix(root);
printf("\n");
/* printf("Enter node to be deleted :- ");
scanf("%d",&nodeToBeDeleted);
root = deleteFromBst(root,nodeToBeDeleted);
*/
ClearTree(&root);
printf("After dispose :%d\n",root->data);
postfix(root);
printf("\n");
return 0;
}
void GifEncode(FILE *fout, UBYTE *pixels, int depth, int siz)
{
GifTree *first = &GifRoot, *newNode, *curNode;
UBYTE *end;
int cc, eoi, next, tel=0;
short cLength;
char *pos, *buffer;
empty[0] = NULL;
need = 8;
nodeArray = empty;
memmove(++nodeArray, empty, 255*sizeof(GifTree **));
if (( buffer = (char *)malloc((BUFLEN+1)*sizeof(char))) == NULL )
TheEnd1("No memory for writing");
buffer++;
pos = buffer;
buffer[0] = 0x0;
cc = (depth == 1) ? 0x4 : 1<<depth;
fputc((depth == 1) ? 2 : depth, fout);
eoi = cc+1;
next = cc+2;
cLength = (depth == 1) ? 3 : depth+1;
if (( topNode = baseNode = (GifTree *)malloc(sizeof(GifTree)*4094)) == NULL )
TheEnd1("No memory for GIF-code tree");
if (( nodeArray = first->node = (GifTree **)malloc(256*sizeof(GifTree *)*noOfArrays)) == NULL )
TheEnd1("No memory for search nodes");
lastArray = nodeArray + ( 256*noOfArrays - cc);
ClearTree(cc, first);
pos = AddCodeToBuffer(cc, cLength, pos);
end = pixels+siz;
curNode = first;
while(pixels < end) {
if ( curNode->node[*pixels] != NULL ) {
curNode = curNode->node[*pixels];
tel++;
pixels++;
chainlen++;
continue;
} else if ( curNode->typ == SEARCH ) {
newNode = curNode->nxt;
while ( newNode->alt != NULL ) {
if ( newNode->ix == *pixels ) break;
newNode = newNode->alt;
}
if (newNode->ix == *pixels ) {
tel++;
pixels++;
chainlen++;
curNode = newNode;
continue;
}
}
/* ******************************************************
* If there is no more thread to follow, we create a new node. If the
* current node is terminating, it will become a SEARCH node. If it is
* a SEARCH node, and if we still have room, it will be converted to a
* LOOKUP node.
*/
newNode = ++topNode;
switch (curNode->typ ) {
case LOOKUP:
newNode->nxt = NULL;
newNode->alt = NULL,
curNode->node[*pixels] = newNode;
break;
case SEARCH:
if ( nodeArray != lastArray ) {
nodeArray += cc;
curNode->node = nodeArray;
curNode->typ = LOOKUP;
curNode->node[*pixels] = newNode;
curNode->node[(curNode->nxt)->ix] = curNode->nxt;
lookuptypes++;
newNode->nxt = NULL;
newNode->alt = NULL,
curNode->nxt = NULL;
break;
}
/* otherwise do as we do with a TERMIN node */
case TERMIN:
newNode->alt = curNode->nxt;
newNode->nxt = NULL,
curNode->nxt = newNode;
curNode->typ = SEARCH;
break;
default:
fprintf(stderr, "Silly node type: %d\n", curNode->typ);
}
newNode->code = next;
newNode->ix = *pixels;
newNode->typ = TERMIN;
newNode->node = empty;
nodecount++;
/*
* End of node creation
* ******************************************************
*/
if (debugFlag) {
if (curNode == newNode) fprintf(stderr, "Wrong choice of node\n");
if ( curNode->typ == LOOKUP && curNode->node[*pixels] != newNode ) fprintf(stderr, "Wrong pixel coding\n");
if ( curNode->typ == TERMIN ) fprintf(stderr, "Wrong Type coding; frame no = %d; pixel# = %d; nodecount = %d\n", count, tel, nodecount);
}
pos = AddCodeToBuffer(curNode->code, cLength, pos);
if ( chainlen > maxchainlen ) maxchainlen = chainlen;
chainlen = 0;
if(pos-buffer>BLOKLEN) {
buffer[-1] = BLOKLEN;
fwrite(buffer-1, 1, BLOKLEN+1, fout);
buffer[0] = buffer[BLOKLEN];
buffer[1] = buffer[BLOKLEN+1];
buffer[2] = buffer[BLOKLEN+2];
buffer[3] = buffer[BLOKLEN+3];
pos -= BLOKLEN;
}
curNode = first;
if(next == (1<<cLength)) cLength++;
next++;
if(next == 0xfff) {
ClearTree(cc,first);
pos = AddCodeToBuffer(cc, cLength, pos);
if(pos-buffer>BLOKLEN) {
buffer[-1] = BLOKLEN;
fwrite(buffer-1, 1, BLOKLEN+1, fout);
buffer[0] = buffer[BLOKLEN];
buffer[1] = buffer[BLOKLEN+1];
buffer[2] = buffer[BLOKLEN+2];
buffer[3] = buffer[BLOKLEN+3];
pos -= BLOKLEN;
}
next = cc+2;
cLength = (depth == 1)?3:depth+1;
}
}
pos = AddCodeToBuffer(curNode->code, cLength, pos);
if(pos-buffer>BLOKLEN-3) {
buffer[-1] = BLOKLEN-3;
fwrite(buffer-1, 1, BLOKLEN-2, fout);
buffer[0] = buffer[BLOKLEN-3];
buffer[1] = buffer[BLOKLEN-2];
buffer[2] = buffer[BLOKLEN-1];
buffer[3] = buffer[BLOKLEN];
buffer[4] = buffer[BLOKLEN+1];
pos -= BLOKLEN-3;
}
pos = AddCodeToBuffer(eoi, cLength, pos);
pos = AddCodeToBuffer(0x0, -1, pos);
buffer[-1] = pos-buffer;
fwrite(buffer-1, pos-buffer+1, 1, fout);
free(buffer-1); free(first->node); free(baseNode);
if (debugFlag) fprintf(stderr, "pixel count = %d; nodeCount = %d lookup nodes = %d\n", tel, nodecount, lookuptypes);
return;
}
Move MCTSTree::BestMove(Player player, Board& board) {
ClearTree();
ASSERT (!board.IsFull());
ASSERT (root != NULL);
MCTSNode* current_node;
uint current_level;
typedef MCTSNode* mcts_node_ptr;
mcts_node_ptr path[ultimate_depth + 1];
uint full_path[ultimate_depth + 1];
path[0] = root.GetPointer();
Board brd;
if (root->children == NULL) {
root->Expand(board);
root_children_number = board.MovesLeft();
}
for (uint i = 0; i < playouts_per_move; ++i) {
current_level = 0;
current_node = root.GetPointer();
brd.Load(board);
while (current_node->children != NULL) {
if (max_depth == 0)
current_node = ¤t_node->children[Rand::next_rand(brd.MovesLeft())];
else current_node = current_node->FindChildToSelect(brd.MovesLeft());
brd.PlayLegal(Move(brd.CurrentPlayer(), current_node->loc));
path[++current_level] = current_node;
full_path[current_level] = current_node->loc.GetPos();
}
if (current_level < max_depth && brd.MovesLeft() > 0 &&
current_node->uct_stats.played >= visits_to_expand +
2 * Params::initialization) {
current_node->Expand(brd);
current_node = current_node->FindChildToSelect(brd.MovesLeft());
brd.PlayLegal(Move(brd.CurrentPlayer(), current_node->loc));
path[++current_level] = current_node;
full_path[current_level] = current_node->loc.GetPos();
}
Player current = brd.CurrentPlayer();
Player winner = RandomFinish(brd, full_path, current_level);
for (int level = current_level; level >= 0; --level) {
if (winner != current)
path[level]->uct_stats.won++;
path[level]->uct_stats.played++;
path[level]->SetInvalidUCB();
current = current.Opponent();
}
for (int level = board.MovesLeft(); level > 0; --level) {
uint pos = full_path[level];
int tree_level = current_level - 1;
if (tree_level >= level)
tree_level = level - 1;
else if (((level + tree_level) & 1) == 0)
tree_level--;
if ((tree_level & 1) == 0)
current = player;
else current = player.Opponent();
while (tree_level >= 0) {
MCTSNode* updated = path[tree_level]->pos_to_children_mapping[pos];
if (winner == current)
updated->rave_stats.won++;
updated->rave_stats.played++;
updated->SetInvalidRAVE();
tree_level -= 2;
}
}
}
MCTSNode* best = root->FindBestChild(board.MovesLeft());
current_player = current_player.Opponent();
return Move(player, best->loc);
}
inline void MCTSTree::Reset() {
ClearTree();
}
void COptionTreeWrapper::DeInit()
{
ClearTree();
}
void main()
{
CBTType *root=NULL;
char menusel;
void (*TreeNodeData1)(CBTType *p);
TreeNodeData1=TreeNodeData;
root = InitTree();
do{
printf("请选择菜单添加二叉树的节点\n");
printf("0.退出\t");
printf("1.添加二叉树的节点\n");
menusel = getch();
switch(menusel)
{
case '1':
AddTreeNode(root);
break;
case '0':
break;
default:
;
}
}while(menusel != '0');
do{
printf("请选择菜单遍历二叉树，输入0表示退出：\n");
printf("1.先序遍历DLR\t");
printf("2.中序遍历LDR\n");
printf("3.后序遍历LRD\t");
printf("4.按层遍历\n");
menusel = getch();
switch(menusel)
{
case '0':
break;
case '1':
printf("\n 先序遍历DLR的结果：");
DLRTree(root,TreeNodeData1);
printf("\n");
break;
case '2':
printf("\n中序遍历LDR的结果：");
LDRTree(root,TreeNodeData1);
printf("\n");
break;
case '3':
printf("\n 后序遍历LRD的结果：");
LRDTree(root,TreeNodeData1);
printf("\n");
break;
case '4':
printf("\n 按层遍历的结果：");
LevelTree(root,TreeNodeData1);
printf("\n");
break;
default:
;
}
}while(menusel != '0');
printf("\n 二叉树深度为：%d \n",TreeDepth(root));
ClearTree(root);
root = NULL;
}
KUiShowWndTree::~KUiShowWndTree()
{
ClearTree();
}
