void releaseTree(Node * a) {
if (a == NIL)
return;
releaseTree(a->left);
releaseTree(a->right);
free(a);
}
void AABBTree::releaseTree(AABBNode *node)
{
if( node!= nullptr )
{
releaseTree(node->leftChild);
releaseTree(node->rightChild);
delete node->leftChild;
delete node->rightChild;
}
}
int main()
{
int i;
int times;
//NodeType dynamicNum[] = {1, 3, 0, 3, 5, 3, 8, 1, 6, 9, 4};
// NodeType callNum[][CALL_NUM_LENGHT] =
// {
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 9, 4},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 9, 7},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 8, 4},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 8, 5},
// {1, 3, 3, 3, 5, 3, 8, 1, 5, 3, 5},
// {1, 3, 3, 3, 5, 3, 8, 1, 5, 2, 5},
//
// {1, 2, 3, 3, 5, 3, 8, 1, 6, 9, 4},
// {1, 2, 4, 3, 5, 3, 8, 1, 6, 9, 7},
// {1, 5, 3, 3, 5, 3, 8, 1, 6, 8, 4},
// {1, 4, 3, 3, 5, 3, 8, 1, 6, 8, 5},
// {1, 8, 3, 3, 5, 3, 8, 1, 5, 3, 5},
// {1, 9, 3, 3, 5, 3, 8, 1, 5, 2, 5},
// };
NodeType dynamicNum[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
NodeType dynamicNumC[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//times = GetTickCount();
Tree *pTree;
pTree = createTree();
for (i=0; i<TIMES_COUNT; i++)
{
BOOL ret;
incCallNum(dynamicNum, sizeof(dynamicNum));
//printfCallNumber(dynamicNum, sizeof(dynamicNum));
ret = addCallNumber(pTree, dynamicNum, sizeof(dynamicNum));
if (ret == FALSE)
printf("add node failed.\n");
}
printf("del...\n");
//getchar();
for (i=0; i<TIMES_COUNT; i++)
{
delCallNumber(pTree, dynamicNum, sizeof(dynamicNum));
//printfCallNumber(dynamicNum, sizeof(dynamicNum));
decCallNum(dynamicNum, sizeof(dynamicNum));
}
releaseTree(pTree);
pTree = NULL;
displayTree(pTree);
printf("\n");
printf("ok\n");
getchar();
return 0;
}
int releaseTree(mp3Node* root)
{
mp3Node* tleft;
mp3Node* tright;
if(root == NULL)
return 0;
tleft = root->left;
tright = root->right;
free(root->data);
free(root);
return releaseTree(tleft) + 1 + releaseTree(tright);
}
// Helper method for memory management
void releaseTree(struct BFTreeNode* node) {
int value;
struct QueueNode* child;
if (node->nodeWrapped->children->length == 0) {
freeNode(node);
}
while (node->nodeWrapped->children->length > 0) {
child = deQueue(node->nodeWrapped->children);
releaseTree(child->thisNode);
}
}
static void clean(
char *dirName
){
/**
| Does the job for the directory "dirName".
|
| Builds a structure holding the TeX-related files, and does the
| required cleanup; finally, removes the file structure.
| If the list appended to "dirs" has been filled, recurse over the
| tree of subdirectories.
**/
Froot *teXTree; /* Root node of the TeX-related files */
Froot *dirs; /* Subdirectories in this directory */
Fnode *pFN; /* Running pointer over subdirectories */
if ((dirs = calloc(2, sizeof(Froot))) == 0) {
noMemory();
}
dirs->extension = "subs";
if ((teXTree = buildTree(dirName, dirs)) != 0) {
if (output_level >= DEBUG) {
printTree(teXTree);
}
examineTree(teXTree, dirName);
releaseTree(teXTree);
}
for (pFN = dirs->firstNode; pFN != 0; pFN = pFN->next) {
clean(pFN->name);
}
releaseTree(dirs);
}
int main(int argc, char *argv[])
{
struct tree at;
int op,lr,parent,child;
initTree(&at);
while(scanf("%d",&op)==1 && op!=0){
switch(op){
case 1://insert node
scanf("%d%d%d",&parent,&lr,&child);
printf("insert node(p=%d lr=%d c=%d):",parent,lr,child);
if(insertTreeNode(&at,parent,lr,child)){
printf("success\n");
}else{
printf("fail\n");
}
break;
case 2://breadfirst traversal
printf("breadthfirst:");
breadthFirstTraversal(&at);
printf("\n");
break;
case 3://pre order traversal
printf("depth preorder:");
depthFirstTraversal(&at,PREORDER);
printf("\n");
break;
case 4://in order traversal
printf("depth inorder:");
depthFirstTraversal(&at,INORDER);
printf("\n");
break;
case 5://post order traversal
printf("depth postorder:");
depthFirstTraversal(&at,POSTORDER);
printf("\n");
break;
default:
printf("error operator\n");
break;
}
}
releaseTree(&at);
return 0;
}
AABBTree::~AABBTree()
{
releaseTree(mRoot);
}
int main(
int argc,
char *argv[]
){
Froot *dirNames; /* To hold the directories to be scanned */
Fnode *pFN; /* Running pointer over directory names */
int to_bExt = FALSE; /* Flag "next parameter to bExt" */
/**
| Scans the arguments appropriately; the required directories are stored
| in the linked list starting at "dirNames".
**/
programName = baseName(argv[0]);
if ((dirNames = calloc(2, sizeof(Froot))) == 0) {
noMemory();
}
dirNames->extension = "argv";
while (--argc) {
if ((*++argv)[0] == '-') {
switch ( (*argv)[1] ) {
case 'i': case 'I':
confirm = TRUE;
break;
case 'r': case 'R':
recurse = TRUE;
break;
case 'k': case 'K':
keep = TRUE;
break;
case 'b': case 'B':
to_bExt = TRUE;
break;
case 'q': case 'Q':
output_level = QUIET;
break;
case 'v': case 'V':
output_level = VERBOSE;
break;
case 'd': case 'D':
output_level = DEBUG;
break;
case 'p': case 'P':
pretend = TRUE;
break;
case 'o': case 'O':
older = TRUE;
break;
default:
syntax();
}
} else {
if (to_bExt) {
strcpy(bExt, *argv);
to_bExt = FALSE;
} else {
insertNode(*argv, 0, 0, 0, dirNames);
}
}
}
if (to_bExt) {
syntax();
}
n_bExt = strlen(bExt);
/**
| If no parameter has been given, clean the current directory
**/
if ((pFN = dirNames->firstNode) == 0) {
clean(".");
} else {
while (pFN != 0) {
clean(pFN->name);
pFN = pFN->next;
}
}
releaseTree(dirNames);
return EXIT_SUCCESS;
}
// Discharging
void treeFree(void) {
releaseTree(root);
}
