void heightTest(void){
treeADT treeOrd,treeRev,treeRan;
int i,TEST_SIZE,NUM_OF_TESTS;
double sum=0;
system("cls");
printf("Tree Height Tester\n\n");
printf("Enter tree size: ");
TEST_SIZE=GetInteger();
if(TEST_SIZE<=0)
Error("I refuse!");
printf("Enter number of tests to run: ");
NUM_OF_TESTS=GetInteger();
printf("\n");
if(NUM_OF_TESTS<=0)
Error("I refuse!");
printf("Random input || Tree size: %d || Number of tests: %d\n",TEST_SIZE,NUM_OF_TESTS);
for(i=0;i<NUM_OF_TESTS;i++){
treeRan=buildTestTreeRandom(TEST_SIZE);
sum+=treeHeight(treeRan);
freeTree(treeRan);
}
sum/=NUM_OF_TESTS;
printf("Average height: %.2f\n\n",sum);
sum=0;
if(TEST_SIZE>20000){
printf("Warning! This function uses recursion to measure height\n");
printf("Big inputs makes it sad :-(\n");
printf("To avoid crash, the height is just printed out.\n\n");
printf("Increasing input || Tree size: %d\n",TEST_SIZE);
printf("Average height: %d\n\n",TEST_SIZE);
printf("Decreasing input || Tree size: %d\n",TEST_SIZE);
printf("Average height: %d\n\n",TEST_SIZE);
}
else{
printf("Increasing input || Tree size: %d || Number of tests: %d\n",TEST_SIZE,NUM_OF_TESTS);
for(i=0;i<NUM_OF_TESTS;i++){
treeOrd=buildTestTreeOrdered(TEST_SIZE);
sum+=treeHeight(treeOrd);
freeTree(treeOrd);
}
sum/=NUM_OF_TESTS;
printf("Average height: %.2f\n\n",sum);
sum=0;
printf("Decreasing input || Tree size: %d || Number of tests: %d\n",TEST_SIZE,NUM_OF_TESTS);
for(i=0;i<NUM_OF_TESTS;i++){
treeRev=buildTestTreeReversed(TEST_SIZE);
sum+=treeHeight(treeRev);
freeTree(treeRev);
}
sum/=NUM_OF_TESTS;
printf("Average height: %.2f\n\n",sum);
sum=0;
}
printf("\nPress enter to return.");
getchar();
}
//Frees memory
void freeTree(node *ptr){
if (ptr != NULL) {
freeTree(ptr->left);
freeTree(ptr->right);
free(ptr);
}
}
bool testCase(int *num, int numsSize) {
struct TreeNode *root = buildTree(num, numsSize);
showTree(root);
// How to use serialize and deserialize
char *data = serialize(root);
struct TreeNode *node = deserialize(data);
printf("serialize to [%s]\n", data);
bool r = eqTree(root, node);
printf("deserialize to\n");
if (!r) {
showTree(node);
} else {
printf("same\n");
}
printf("%s\n", expect(r));
freeTree(root);
freeTree(node);
if (data) {
free(data);
}
return r;
}
void freeTree(ANode * tree)
{
Node<Outlook> * o = dynamic_cast<Node<Outlook> *>(tree);
Node<Temperature> * t = dynamic_cast<Node<Temperature> *>(tree);
Node<Humidity> * h = dynamic_cast<Node<Humidity> *>(tree);
Node<Wind> * w = dynamic_cast<Node<Wind> *>(tree);
if (o != NULL)
{
std::map<Outlook, ANode *>::iterator it = o->getChilds().begin();
for (; it != o->getChilds().end(); ++it)
freeTree(it->second);
}
else if (t != NULL)
{
std::map<Temperature, ANode *>::iterator it = t->getChilds().begin();
for (; it != t->getChilds().end(); ++it)
freeTree(it->second);
}
else if (h != NULL)
{
std::map<Humidity, ANode *>::iterator it = h->getChilds().begin();
for (; it != h->getChilds().end(); ++it)
freeTree(it->second);
}
else if (w != NULL)
{
std::map<Wind, ANode *>::iterator it = w->getChilds().begin();
for (; it != w->getChilds().end(); ++it)
freeTree(it->second);
}
delete tree;
}
void freeTree( Tree * t ) {
if( !t ) return;
freeTree( t->left );
freeTree( t->right );
free( t );
}
/* Free tree */
void freeTree(queue *root){
if(root == NULL)
return;
freeTree(root->left);
freeTree(root->right);
free(root);
}
void freeTree(Sprig* thisSprig) {
if (thisSprig == NULL) return;
//free childSprigs first
freeTree(thisSprig->leftSprig);
int i = numLeaves(thisSprig);
Leaf* curr = thisSprig->firstLeaf;
for (; i>0; i--) {
freeTree(curr->childSprig);
curr = curr->nextLeaf;
}
//then free leaves in own scope
curr = thisSprig->firstLeaf;
Leaf* next = curr->nextLeaf;
for(i=numLeaves(thisSprig); i>0; i--) {
free(curr);
curr = next;
if (curr != NULL) next = curr->nextLeaf;
}
//then free self
free(thisSprig);
return;
}
void freeTree(HuffmanNode* node) {
if(node != nullptr){
freeTree(node->zero);
freeTree(node->one);
delete node;
}
}
// Frees a condition and all of it's sub conditions
void freeTree(Condition* c)
{
if (c->lhs) freeTree(c->lhs);
if (c->rhs) freeTree(c->rhs);
free(c);
}
void freeTree(avlNode **node){
if(*node){
freeTree(&(*node)->left);
freeTree(&(*node)->right);
free(*node);
}
}
void testIsEquiv()
{
printf("###########################\n");
printf("Test 5. is_equiv: ");
BTree *t1 = testTree1();
BTree *t2 = testTree2();
if (isEquivBTree(t1, t2)){
printf("NOK - B-stromy nejsou ekvivalentni, nemaji shodnou aritu\n");
}else{
freeTree(t1); freeTree(t2);
t1 = testTree2();
t2 = testTree4();
if (isEquivBTree(t1, t2)){
printf("NOK - B-stromy nejsou ekvivalentni, nemaji shodne hodnoty\n");
}else{
freeTree(t1);
t1 = testTree2();
if (isEquivBTree(t1, t1)){
printf("OK\n");
}else{
printf("NOK - B-stromy jsou ekvivalentni\n");
}
}
}
freeTree(t1); freeTree(t2);
}
void QMapDataBase::freeTree(QMapNodeBase *root, int alignment)
{
if (root->left)
freeTree(root->left, alignment);
if (root->right)
freeTree(root->right, alignment);
qMapDeallocate(root, alignment);
}
void freeTree(TreeNode *T, Tree * Tr) {
if (T->left != NULL)
freeTree(T->left,Tr);
if (T->right != NULL)
freeTree(T->right,Tr);
Tr->destroyValue(T->value);
free(T);
}
void freeTree(Ast* temp) {
if ( temp ) {
Ast* left = temp->getLeft();
Ast* right = temp->getRight();
delete temp;
freeTree(left);
freeTree(right);
}
}
void freeTree(astNode *root) {
if (root != NULL) {
if (root->next != NULL) freeTree(root->next);
if (root->op.left != NULL) freeTree(root->op.left);
if (root->op.right != NULL) freeTree(root->op.right);
if (root->str != NULL) free(root->str);
free(root);
}
}
void _redblacktree::freeTree( tree *root ) {
if( !root ) {
freeTree(root->left);
freeTree(root->right);
}
delete root;
}
void freeTree(t_node *root)
{
if (root)
{
freeTree(root->left);
freeTree(root->right);
free(root);
}
}
void freeTree(struct treeNode *root)
{
if(root != NULL)
{
freeTree(root->left);
freeTree(root->right);
free(root);
}
}
void freeTree(Tree *root)
{
if (root == NULL)
return;
freeTree(root->left);
freeTree(root->right);
if (root->left == NULL && root->right == NULL)
free(root);
}
static void freeTree(ttree_express *r)
{
if (!r)
return;
freeTree(r->left);
freeTree(r->right);
free(r);
}
void freeTree(HuffmanNode* node) {
if (node == nullptr) {
return;
} else {
freeTree(node->zero);
freeTree(node->one);
}
delete node;
}
void freeTree(node_t* t){
if(t->split < 0){
free(t);
}
else{
freeTree(t->left);
freeTree(t->right);
free(t);
}
}
void freeTree(Symbol *root)
{
if (root == nullptr)
return;
if (root->left != nullptr)
freeTree(root->left);
if (root->right != nullptr)
freeTree(root->right);
delete root;
}
void freeTree(TreeNode *tree)
{
if (tree == nullptr)
return;
if (tree->left)
freeTree(tree->left);
if (tree->right)
freeTree(tree->right);
delete tree;
}
void HODLR_Tree::freeTree(node* root){
if (root->isLeaf == true){
delete root;
root = NULL;
return;
}
freeTree(root->left);
freeTree(root->right);
delete root;
root = NULL;
}
void freeTree(Tnode* T)
{
if (T==NULL)
{
return;
}
freeTree(T->right);
freeTree(T->left);
printf("%s\n", T->value);
free(T);
}
void freeTree(node_t* curr){
// Don't do anything if the current node is NULL
if(curr == NULL);
else{
// Free the left, the right, the current word, and then the current node.
freeTree(curr->right);
freeTree(curr->left);
free(curr->word);
free(curr);
}
}
void freeTree(nodo_t * r)
{
if (r != NULL) {
if (r->left != NULL)
freeTree(r->left);
if (r->right != NULL)
freeTree(r->right);
deallocaListIntervallo(r->lint);
free(r);
}
}
// Frees all nodes in the given tree.
//
// INPUT: root - The root of the tree to be freed.
void freeTree(Tree* root)
{
if(root != NULL)
{
freeTree(root->left);
root->left = NULL;
freeTree(root->right);
root->right = NULL;
free(root);
}
}
void freeTree(struct node* head)
{
if(head->lchild)
{
freeTree(head->lchild);
}
if(head->rchild)
{
freeTree(head->rchild);
}
free(head);
}
