void exprTree::destroyTree(Node *leaf) {
	if (leaf != nullptr) {
		destroyTree(leaf->left);
		destroyTree(leaf->right);
		delete leaf;
	}
}

/*prints all the files associated with any word*/
int so(char *str, hashTable *ht) {
  char *word;
  FileNode *fptr; /* Iterates through filenames  */

  if (strcmp(strtok(str, " "), "so") != 0) {
    printf("I did not get 'so' inside sa function!!\n");
    return 1;
  }

  /* goes through each word in input */
  while ((word = strtok(NULL, " "))) {
    for (ptr = getFiles(word, root); ptr != NULL;
        ptr = ptr->next) {
      insert_to_list(t, ptr->filename);
    }
  }

  /* Means we got no matches */
  if (t->files == NULL) {
    printf("No matches found.\n");
    destroyTree(t);
    return 1;
  }

  /* prints all the filenames */
  for (ptr = t->files; ptr->next != NULL; ptr = ptr->next)
    printf("%s, ", ptr->filename);
  if (ptr)
    printf("%s\n", ptr->filename);

  destroyTree(t);
  return 0;
}

void Node::destroyTree(Node *a) {
	if (a != NULL)
	{
		destroyTree(a->left);
		destroyTree(a->right);
		delete a;
	}
};

void destroyTree(node *in){

  if(in != 0){
    destroyTree(in->left);
    destroyTree(in->right);
    free(in);
  }
}

void destroyTree(struct tree* victim){
    if(victim->son1)
       destroyTree(victim->son1);
    if(victim->son2)
       destroyTree(victim->son2);
    free(victim);
    victim = 0; 
}

 void destroyTree(NodePtr leaf) {
   if(leaf != nullptr) {
     destroyTree(leaf->left);
     destroyTree(leaf->right);
     delete leaf;
     --numberOfNodes;
   }
 } 

void bipartGraphDestroy(bpGraph_t* pGraph)
{
	/* TODO: Implement me! */
	destroyTree(pGraph->vpVertsP1);
	destroyTree(pGraph->vpVertsP2);
	safeFree(pGraph, sizeof(bpGraph_t));
	pGraph = NULL;
} /* end of bipartGraphDestroy() */

//--------------------------------------------------------------------------
// void destroyTree(BSTNode* subTreePtr);
// Taken from Carrano et al.: method used to destruct a BST
// Preconditions: BST exists
// Postconditions: BST is destructed
// Return value: None
// Functions called: Recursive call to itself
void BST::destroyTree(BSTNode* subTreePtr) {
   if (subTreePtr != nullptr)
   {
      destroyTree(subTreePtr->left);
      destroyTree(subTreePtr->right);
      delete subTreePtr;
   }
} 

void destroyTree(HuffNode * tree)
/*This function deallocates the memory allocated by the Huffman tree.*/ 
{
  if(tree == NULL){return;}//base case:reach the leaf of the tree, return to free the leaf
  destroyTree(tree -> left);//check all the left children
  destroyTree(tree -> right);//check all the right children
  free(tree);//free the memory of the tree
}

//Deallocates memory for the given root and all its subtrees
//O(h)
void destroyTree(struct tree *root){

    //Since this is a tree, we can use post order recursion to recusrivley delete all the nodes in the left and right subtree then the root
	if(root!=NULL){
		destroyTree(root->left);
		destroyTree(root->right);
		free(root);
	}
}

// Private destroyTree function.  It will delete all the nodes of the tree
void BinaryTree::destroyTree(TreeNode *leaf)
{
	if(leaf!=NULL)
	{
		destroyTree(leaf->left);
		destroyTree(leaf->right);
		delete leaf;
	}
}

void bipartGraphDestroy(bpGraph_t* pGraph)
{
    /* Destroy each partite tree */
    destroyTree(*pGraph->vertices1);
    destroyTree(*pGraph->vertices2);

    /* Free the graph struct */
    safeFree(pGraph, sizeof(pGraph));
} /* end of bipartGraphDestroy() */

void LinkedBinaryTree<T>::destroyTree(Node* p) {
  
  if (p != NULL) {
    destroyTree(p->left);
    destroyTree(p->right);
    delete p;
  }
  
}

void BinaryNodeTree<ItemType>::destroyTree(BinaryNode<ItemType>* subTreePtr)
{
   if (subTreePtr != nullptr)
   {
      destroyTree(subTreePtr->getLeftChildPtr());
      destroyTree(subTreePtr->getRightChildPtr());
      delete subTreePtr;
   }  // end if
}  // end destroyTree

void BST::destroyTree(TreeNode *& treePtr)
{
   // postorder traversal
   if (treePtr != NULL)
   {  destroyTree(treePtr->leftChildPtr);
      destroyTree(treePtr->rightChildPtr);
      delete treePtr;
      treePtr = NULL;
   }  // end if
}  // end destroyTree

void destroyTree(TreeNode * tn)
{
  if (tn == NULL)
    {
      return;
    }
  destroyTree(tn -> left);
  destroyTree(tn -> right);
  free(tn);
}

void destroyTree(node_t* root)
{
	//free all node
	if (root)
	{
		destroyTree(root->left);
		destroyTree(root->right);
		free(root);
	}
}

void destroyTree(BinaryTreeNode* root)
{
	if(root)
	{
		destroyTree(root->m_pLeft);
		destroyTree(root->m_pRight);
		delete root;
		root = 0;
	}
}

void bipartGraphDestroy(bpGraph_t* pGraph)
{
   /* this function checks for NULL */
   destroyTree(pGraph->adjTreeP1);
   destroyTree(pGraph->adjTreeP2);

   safeFree(pGraph->vertExistsP1, pGraph->numVertsP1 * sizeof(char));
   safeFree(pGraph->vertExistsP2, pGraph->numVertsP2 * sizeof(char));

   safeFree(pGraph, sizeof(bpGraph_t));
} /* end of bipartGraphDestroy() */

//----------------------------------------------------------------------------
// DestroyTree
// postorder deletion of nodes in the tree
// @param tree current node passed into recursive function
//
void BinTree::destroyTree(Node*& tree){
	if (tree != NULL){
		destroyTree(tree->left); //destroy left
		destroyTree(tree->right); //destroy right

		delete tree->movie; //delete NodeData
		tree->movie = NULL;
		delete tree; //Delete Node
		tree = NULL;
	}
} //end destroyTree