How to count the occurrences of a string in an AVL tree? - c++

Question

I have an AVL tree program that sorts a text file, stored as a string, using in-order traversal. This works as intended and is shown below
std::string fileName;
std::fstream readFile;
std::string storeFile;
struct Node
{
std::string key;
int height;
Node *left;
Node *right;
};
int max(int a, int b);
int height(Node *N)
{
if (N == NULL)
return 0;
return N->height;
}
int max(int lower, int upper)
{
return (lower > upper) ? lower : upper;
}
Node *newNode(std::string key)
{
Node *node = new Node();
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 1;
return node;
}
Node *rightRotation(Node *y)
{
Node *x = y->left;
Node *z = x->right;
x->right = y;
y->left = z;
y->height = max(height(y->left), height(y->right)) + 1;
x->height = max(height(x->left), height(x->right)) + 1;
return x;
}
Node *leftRotation(Node *x)
{
Node *y = x->right;
Node *z = y->left;
y->left = x;
x->right = z;
x->height = max(height(x->left), height(x->right)) + 1;
y->height = max(height(y->left), height(y->right)) + 1;
return y;
}
// Get Balance factor of node N
int getBalance(Node *N)
{
if (N == NULL)
return 0;
return height(N->left) - height(N->right);
}
Node *insertnewNode(Node *node, std::string key)
{
if (node == NULL)
return (newNode(key));
if (key < node->key)
node->left = insertnewNode(node->left, key);
else if (key > node->key)
node->right = insertnewNode(node->right, key);
else
return node;
node->height = 1 + max(height(node->left),
height(node->right));
int balance = getBalance(node);
if (balance > 1 && key < node->left->key)
return rightRotation(node);
if (balance < -1 && key > node->right->key)
return leftRotation(node);
if (balance > 1 && key > node->left->key)
{
node->left = leftRotation(node->left);
return rightRotation(node);
}
if (balance < -1 && key < node->right->key)
{
node->right = rightRotation(node->right);
return leftRotation(node);
}
return node;
}
void Inorder(Node *root)
{
if (root == NULL)
return;
Inorder(root->left); //visit left sub-tree
std::cout << root->key << std::endl; //visit root(key node)
Inorder(root->right); //visit right sub-tree
}
bool wordCount(const Node &node1, const Node &node2)
{
}
int main(int argc, char *argv[])
{
Node *root = NULL; //pointer to bstNode. Store address of root node.
//set to NULL(empty tree)
std::cout << "Please enter the name of the file: " << std::endl; //prompts user for the filename
std::cin >> argv[0]; //stores the filename is the first element of argv[]
fileName = argv[0];
std::cout << "Attempting to read file " << fileName << std::endl;
readFile.open(fileName); //attempts to read the file
if (!readFile)
{
std::cerr << "ERROR: failed to open file " << std::endl; //if the file cannot be opened an error is displayed
exit(0); //if it cannot open the console terminates
}
else
{
std::cerr << "File successfully opened" << std::endl;
}
while (readFile >> storeFile)
{
std::transform(storeFile.begin(), storeFile.end(), storeFile.begin(), ::tolower);
for (int i = 0, len = storeFile.size(); i < len; i++)
{
// check whether parsing character is punctuation or not
if (ispunct(storeFile[i]))
{
storeFile.erase(std::remove_if(storeFile.begin(), storeFile.end(), ::isspace), storeFile.end());
storeFile.erase(std::remove_if(storeFile.begin(), storeFile.end(), ::ispunct), storeFile.end());
}
}
root = insertnewNode(root, storeFile);
}
Inorder(root);
readFile.close();
return 0;
}
The implementation im currently struggling with is the count of each word. So for exmaple below, the word is on the left and the count is on the right
adams: 2
apple: 5
as: 20
I attempted a function called bool countWords which the paramaters I believe would be needed(in this case two nodes to compare and match a case). However im not to sure myself how to implemenent it
Thankyou

Answer 1

Just because this hasn't been answered yet, here's the idea behind the solution which I've proposed. You have already converted the input from the file to lowercase, so we can assume that all of the strings are the same case:
typedef std::map<std::string, uint32_t> omap;
omap occurrences;
void printNumOccur( const omap& m )
{
for ( omap::it = m.begin(); it != m.end(); ++it )
{
std::cout << it->first << ": " << it->second << std::endl;
}
}
Node *insertnewNode(Node *node, std::string key)
{
if (node == NULL)
return (newNode(key));
omap::iterator it;
if ( (it = occurrences.find(key)) != m.end() )
it->second++;
else
occurrences.insert({key, 1});
if (key < node->key)
node->left = insertnewNode(node->left, key);
else if (key > node->key)
node->right = insertnewNode(node->right, key);
else
return node;
node->height = 1 + max(height(node->left),
height(node->right));
int balance = getBalance(node);
if (balance > 1 && key < node->left->key)
return rightRotation(node);
if (balance < -1 && key > node->right->key)
return leftRotation(node);
if (balance > 1 && key > node->left->key)
{
node->left = leftRotation(node->left);
return rightRotation(node);
}
if (balance < -1 && key < node->right->key)
{
node->right = rightRotation(node->right);
return leftRotation(node);
}
return node;
}

Answer 2

It seems like the easiest approach would be to maintain the count of each string in the node and increment it every time a matching node is found.
struct Node
{
std::string key;
int height;
Node *left;
Node *right;
int count;
};
Node* newNode(std::string const& key)
{
Node *node = new Node();
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 1;
node->count = 1;
return node;
}
if (key < node->key)
node->left = insertnewNode(node->left, key);
else if (key > node->key)
node->right = insertnewNode(node->right, key);
else
{
node->count++;
return node;
}
Once the tree is assembled you will need to iterate all nodes. There are two ways you could do this:
Whenever creating a new node, add a pointer to it in a vector
Write a "TreeBrowser" class to scan the tree and dump the outputs. If you want the output to be in order, you will need to walk up and down the tree, remembering what level each branch started from.