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);
}