/**
* @brief helper for copy-constructor
* @details recursively copy nodes from a tree pre-order
*
* @param origNode Node on the original tree to be copied over
*/
void TBST::recursiveCopy(Node* origNode) {
if(origNode != NULL) {
if(origNode->isLeaf()) {
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
} else if(!origNode->hasLeftChild()) {
// 1: have right child, no left child
// copy the node
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy the right child
recursiveCopy(origNode->getRight());
} else if(!origNode->hasRightChild()) {
// 2: have left child, no right child
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy the left child
recursiveCopy(origNode->getLeft());
} else {
// 3: have children on both sides
NodeData* d = origNode->getData();
insert(d->getToken(), d->getCount());
d = NULL;
// then recurse down and copy both children
recursiveCopy(origNode->getLeft());
recursiveCopy(origNode->getRight());
}
}
}
NodeData testSetters(NodeData& B) {
NodeData A("a");
A.decreaseCount();
assert(A.getCount() == 0);
int bCount = 7;
while(B.getCount() < bCount) {
B.increaseCount();
}
assert(B.getCount() == bCount);
assert(A.getToken() < B.getToken());
A = B;
assert(A.getToken() == B.getToken());
return B;
}
NodeData testConstructors() {
NodeData A;
assert(A.getToken() == "");
assert(A.getCount() == 1);
NodeData B("hello world");
assert(B.getToken() == "hello world");
NodeData C(B);
assert(C.getToken() == "hello world");
return B;
}
/**
* @brief Recursively query for max NodeDatas from left/right subtrees
* and compare.
* @details private recursive method. Compares maximum candidates from the root
* node, the left subtree, and the right subtree. O(n) running time.
*
* @param subroot Node pointer to the root of the subtree currently recursed on
* @return NodeData with maximum secondary value among the 3 candidates
*/
NodeData* TBST::getMaxByFrequency(Node* subroot) {
if(subroot != NULL) {
NodeData* maxData = subroot->getData(); // default max
NodeData* leftMax = NULL; NodeData* rightMax = NULL;
if(subroot->hasLeftChild())
leftMax = getMaxByFrequency(subroot->getLeft());
if(subroot->hasRightChild())
rightMax = getMaxByFrequency(subroot->getRight());
if(leftMax != NULL && maxData->getCount() < leftMax->getCount())
maxData = leftMax;
// break ties in favor of the right branch since we desire an
// increasing sort order
if(rightMax != NULL && maxData->getCount() <= rightMax->getCount())
maxData = rightMax;
return maxData;
}
else return NULL;
}
/**
* @brief Recursively query for max NodeDatas from left/right subtrees
* and compare.
* @details private recursive method. Compares minimum candidates from the root
* node, the left subtree, and the right subtree. Runs in O(n) time.
*
* @param subroot Node pointer to the root of the subtree currently recursed on
* @return NodeData with minimum secondary value among the 3 candidates
*/
NodeData* TBST::getMinByFrequency(Node* subroot) {
if(subroot != NULL) {
NodeData* minData = subroot->getData(); // default min
NodeData* leftMin = NULL; NodeData* rightMin = NULL;
if(subroot->hasLeftChild())
leftMin = getMinByFrequency(subroot->getLeft());
if(subroot->hasRightChild())
rightMin = getMinByFrequency(subroot->getRight());
// break ties in favor of the node on the left since we want increasing
// sort order
if(leftMin != NULL && minData->getCount() >= leftMin->getCount()) {
minData = leftMin;
}
if(rightMin != NULL && minData->getCount() > rightMin->getCount()) {
minData = rightMin;
}
return minData;
}
else return NULL;
}
/**
* @brief copy constructor
* @details creates a copy of the passed in TBST
*
* @param other TBST tree to copy
*/
TBST::TBST(const TBST& other) {
root = NULL;
nodeCount = 0;
if(other.root != NULL) {
// handle root separately
assert(root == NULL); // make sure that tree is empty
// then add the root
NodeData* rootData = other.root->getData();
insert(rootData->getToken(), rootData->getCount());
// recursively copy the left and right subtrees
recursiveCopy(other.root->getLeft());
recursiveCopy(other.root->getRight());
}
else {
root = NULL;
}
}
