HEY , CAN ANYBODY CAN HELP ME WITH THIS DATA STRUCTURE ASSIGNMENT,

FREQUENCY_H

/* * frequency.h The Frequency class makes it easier to create a tree of word counts. For example, by using this class you will be able to do create a binary tree of binary_tree_node >*. Note that the space after the second closing > is required. frequency() Sets Item to blank and frequency to 0. Be careful with this one, recommend the using the other constructor only. If you use this one you will have to increment frequency when you update the data field. frequency(Item i) Constructor with an Item, will initialize frequency to 1 // MODIFICATION MEMBER FUNCTIONS Item& data( ) Return the data_field that you can change size_t& operator++() size_t operator++(int) Increments the frequency count only bool isDataInc(Item i) If i matching the objects data, then it increments the frequency and returns true // CONST MEMBER FUNCTIONS const Item& data( ) const Return the data_field that you cannot change bool isData(Item i) const If i matching the objects data, then it returns true size_t count( ) const Return the frequency bool operator (Item b) bool operator> (Item b) Use this to help decide where a new node should be placed based on data. This will compare the data_field. Both const and non const versions provided. bool operator (size_t b) bool operator> (size_t b) Use this to help decide where a node should be placed based on frequency count. This will compare the freq.field. Both const and non const versions provided. std::ostream& operator& f) Outputs the frequency and data_field is a friendly format, no spaces data_field[freq_field] */ #ifndef FREQUENCY_H_ #define FREQUENCY_H_ namespace FREQPROJ { template  class frequency { public: frequency() { data_field=Item(); freq_field=0; } frequency(Item i) { data_field=i; freq_field=1; } // MODIFICATION MEMBER FUNCTIONS Item& data( ) { return data_field; } frequency& operator++() { ++freq_field; return *this; } //pre frequency operator++(int) { frequency tmp(*this); operator++(); return tmp; } //post bool isDataInc(Item i) { return (i == data_field && (freq_field += 1)); } // CONST MEMBER FUNCTIONS const Item& data( ) const { return data_field; } bool isData(Item i) const { return i == data_field; } size_t count( ) const { return freq_field; } bool operator (Item b) { return data_field > b; } bool operator> (Item b) const { return data_field > b; } bool operator> (size_t b) { return freq_field > b; } bool operator> (size_t b) const { return freq_field > b; } private: Item data_field; size_t freq_field; }; template  std::ostream& operator& f) { out  bool operator > (Item left, frequency& right ) { return left > right.data() ; } template  bool operator & right ) { return left  bool operator & right ) { return left  bool operator > (std::size_t left, frequency& right ) { return left > right.count() ; } //End of comparisons } //end namespace #endif /* FREQUENCY_H_ */ 

BINTREE_H file

// FILE: bintree.h (part of the namespace main_savitch_10) // PROVIDES: A template class for a node in a binary tree and functions for // manipulating binary trees. The template parameter is the type of data in // each node. // // TYPEDEF for the binary_tree_node template class: // Each node of the tree contains a piece of data and pointers to its // children. The type of the data (binary_tree_node::value_type) is // the Item type from the template parameter. The type may be any of the C++ // built-in types (int, char, etc.), or a class with a default constructor, // and an assignment operator. // // CONSTRUCTOR for the binary_tree_node class: // binary_tree_node( // const item& init_data = Item( ), // binary_tree_node* init_left = NULL, // binary_tree_node* init_right = NULL // ) // Postcondition: The new node has its data equal to init_data, // and it's child pointers equal to init_left and init_right. // // MEMBER FUNCTIONS for the binary_tree_node class: // const item& data( ) const  // void inorder(Process f, BTNode* node_ptr) // Precondition: node_ptr is a pointer to a node in a binary tree (or // node_ptr may be NULL to indicate the empty tree). // Postcondition: If node_ptr is non-NULL, then the function f has been // applied to the contents of *node_ptr and all of its descendants, using // an in-order traversal. // Note: BTNode may be a binary_tree_node or a const binary tree node. // Process is the type of a function f that may be called with a single // Item argument (using the Item type from the node). // // tempate  // void postorder(Process f, BTNode* node_ptr) // Same as the in-order function, except with a post-order traversal. // // tempate  // void preorder(Process f, BTNode* node_ptr) // Same as the in-order function, except with a pre-order traversal. // // template  // void print(const binary_tree_node* node_ptr, SizeType depth) // Precondition: node_ptr is a pointer to a node in a binary tree (or // node_ptr may be NULL to indicate the empty tree). If the pointer is // not NULL, then depth is the depth of the node pointed to by node_ptr. // Postcondition: If node_ptr is non-NULL, then the contents of *node_ptr // and all its descendants have been written to cout with the  // void tree_clear(binary_tree_node*& root_ptr) // Precondition: root_ptr is the root pointer of a binary tree (which may // be NULL for the empty tree). // Postcondition: All nodes at the root or below have been returned to the // heap, and root_ptr has been set to NULL. // // template  // binary_tree_node* tree_copy(const binary_tree_node* root_ptr) // Precondition: root_ptr is the root pointer of a binary tree (which may // be NULL for the empty tree). // Postcondition: A copy of the binary tree has been made, and the return // value is a pointer to the root of this copy. // // template  // size_t tree_size(const binary_tree_node* node_ptr) // Precondition: node_ptr is a pointer to a node in a binary tree (or // node_ptr may be NULL to indicate the empty tree). // Postcondition: The return value is the number of nodes in the tree. #ifndef BINTREE_H #define BINTREE_H #include  // Provides assert #include  // Provides NULL, std::size_t #include  // Provides std::setw #include  // Provides std::cout namespace FREQPROJ { template  class binary_tree_node { public: // TYPEDEF typedef Item value_type; // CONSTRUCTOR binary_tree_node( const Item& init_data = Item( ), binary_tree_node* init_left = NULL, binary_tree_node* init_right = NULL ) { data_field = init_data; left_field = init_left; right_field = init_right; } // MODIFICATION MEMBER FUNCTIONS Item& data( ) { return data_field; } binary_tree_node* left( ) { return left_field; } binary_tree_node* right( ) { return right_field; } void set_data(const Item& new_data) { data_field = new_data; } void set_left(binary_tree_node* new_left) { left_field = new_left; } void set_right(binary_tree_node* new_right) { right_field = new_right; } // CONST MEMBER FUNCTIONS const Item& data( ) const { return data_field; } const binary_tree_node* left( ) const { return left_field; } const binary_tree_node* right( ) const { return right_field; } bool is_leaf( ) const { return (left_field == NULL) && (right_field == NULL); } private: Item data_field; binary_tree_node *left_field; binary_tree_node *right_field; }; // NON-MEMBER FUNCTIONS for the binary_tree_node: template  void inorder(Process f, BTNode* node_ptr); template  void preorder(Process f, BTNode* node_ptr); template  void postorder(Process f, BTNode* node_ptr); template  void print(binary_tree_node* node_ptr, SizeType depth); template  void tree_clear(binary_tree_node*& root_ptr); template  binary_tree_node* tree_copy(const binary_tree_node* root_ptr); template  std::size_t tree_size(const binary_tree_node* node_ptr); //Implementation (formerly bintree.template template  void inorder(Process f, BTNode* node_ptr) // Library facilities used: cstdlib { if (node_ptr != NULL) { inorder(f, node_ptr->left( )); f( node_ptr->data( ) ); inorder(f, node_ptr->right( )); } } template  void postorder(Process f, BTNode* node_ptr) // Library facilities used: cstdlib { if (node_ptr != NULL) { postorder(f, node_ptr->left( )); postorder(f, node_ptr->right( )); f(node_ptr->data( )); } } template  void preorder(Process f, BTNode* node_ptr) // Library facilities used: cstdlib { if (node_ptr != NULL) { f( node_ptr->data( ) ); preorder(f, node_ptr->left( )); preorder(f, node_ptr->right( )); } } template  void print(binary_tree_node* node_ptr, SizeType depth) // Library facilities used: iomanip, iostream, stdlib { if (node_ptr != NULL) { print(node_ptr->right( ), depth+1); std::cout data( ) left( ), depth+1); } } template  void tree_clear(binary_tree_node*& root_ptr) // Library facilities used: cstdlib { binary_tree_node* child; if (root_ptr != NULL) { child = root_ptr->left( ); tree_clear( child ); child = root_ptr->right( ); tree_clear( child ); delete root_ptr; root_ptr = NULL; } } template  binary_tree_node* tree_copy(const binary_tree_node* root_ptr) // Library facilities used: cstdlib { binary_tree_node *l_ptr; binary_tree_node *r_ptr; if (root_ptr == NULL) return NULL; else { l_ptr = tree_copy( root_ptr->left( ) ); r_ptr = tree_copy( root_ptr->right( ) ); return new binary_tree_node( root_ptr->data( ), l_ptr, r_ptr); } } template  size_t tree_size(const binary_tree_node* node_ptr) // Library facilities used: cstdlib { if (node_ptr == NULL) return 0; else return 1 + tree_size(node_ptr->left( )) + tree_size(node_ptr->right( )); } } #endif 

WORDSCOLLECTION_H

// // wordscollection.cpp // // Created on: Oct 26, 2016 // Author: S. Miller // // Constructor // wordscollection( std::string& filename ) // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // bool tokenizeFile( std::string& filename ) // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // bool tokenizeFile( char * filename ) // Convenience function if you wanted to pass a hardcoded filename string (cstr) to tokenize, otherwise same as above // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // std::string getNextToken(); // Precondition: WORD Tokens are STILL available in the queue // Postcondition: Next token is POPPED from QUEUE and returned // // bool hasTokens() const; // Precondition: N/A // Postcondition: True if the WORD token queue is NOT empty // #ifndef WORDSCOLLECTION_H_ #define WORDSCOLLECTION_H_ #include  #include  namespace FREQPROJ { class wordscollection { public: wordscollection() { //Empty queue words = std::queue<:string>(); } wordscollection( std::string& ); wordscollection( char * ); ~wordscollection() { //words queue will be destroyed by queue destructor } bool tokenizeFile( std::string& ); bool tokenizeFile( char * ); std::string getNextToken(); bool hasTokens() const; private: std::queue<:string> words; }; } /* namespace FREQPROJ */ #endif /* WORDSCOLLECTION_H_ */ 

WORDSCOLLECTION.CPP

// // wordscollection.cpp // // Created on: Oct 26, 2016 // Author: S. Miller // // Constructor // wordscollection( std::string& filename ) // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // bool tokenizeFile( std::string& filename ) // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // bool tokenizeFile( char * filename ) // Convenience function if you wanted to pass a hardcoded filename string (cstr) to tokenize, otherwise same as above // Precondition: Filename is a local file that EXISTS and is readable, file should be a text file // Postcondition: File is read into the objects queue for later processing // // std::string getNextToken(); // Precondition: WORD Tokens are STILL available in the queue // Postcondition: Next token is POPPED from QUEUE and returned // // bool hasTokens() const; // Precondition: N/A // Postcondition: True if the WORD token queue is NOT empty // #include  #include  #include "wordscollection.h" namespace FREQPROJ { wordscollection::wordscollection( std::string& f) { tokenizeFile(f); } wordscollection::wordscollection( char * f) { std::string s(f); tokenizeFile( s ); } bool wordscollection::tokenizeFile(std::string& filename) { std::string s,sWord; std::ifstream fin; fin.open( filename.c_str(), std::ifstream::in); if ( !fin.fail() ) { while ( fin ) { s = ""; while ( fin && !isalpha(fin.peek()) ) fin.ignore(); if ( fin && isalpha(fin.peek()) ) { //fin.ignore(); //Possible HTML Tagname, tagnames end in >, SPACE, [, or newline (carriage return too) while ( fin && isalpha(fin.peek()) ) s += tolower(fin.get()); //Got word words.push(s); } } } else { throw std::runtime_error("Unable to open/read file!"); } fin.close(); return true; } bool wordscollection::tokenizeFile( char * filename ) { std::string s(filename); return tokenizeFile( s ); } std::string wordscollection::getNextToken() { if ( hasTokens() ) { std::string s = words.front(); words.pop(); return s; } else { throw std::runtime_error("Tokens underflow!"); } return ""; //To appease the compiler } bool wordscollection::hasTokens() const { return !words.empty(); } } /* namespace FREQPROJ */ 

2. Program objective: The purpose of this assignment is to get some practice working with binary search trees. It is highly recommended that you work out a design to solve this problem on paper first, before writing any code. You are to write a program to create a frequency list of words in a passage. A frequency list is a list of the distinct words in the passage together with a cout of the number of times that word occurs. The input will be read from a file (filename provided as first argument on commandline). The output is to be sent to stdout (i.e. cout, sorted alphabetically on the words. The output would also contain an output of the words sorted by frequency count For each word that is read, we will convert the characters to lower case [so that The and the are counted together and remove punctuation. The provided wordcollection class does this work for you. You can use a binary tree, sorted on the words, to hold the words and their counts, use the frequency class to make life easier. If a word is seen again, increment the count. I want you to utilize bintree.h to assist in creating and working with the tree. All output of the tree should utilize the inorder, preorder, or postorder convenience traversal functions. 2. Program objective: The purpose of this assignment is to get some practice working with binary search trees. It is highly recommended that you work out a design to solve this problem on paper first, before writing any code. You are to write a program to create a frequency list of words in a passage. A frequency list is a list of the distinct words in the passage together with a cout of the number of times that word occurs. The input will be read from a file (filename provided as first argument on commandline). The output is to be sent to stdout (i.e. cout, sorted alphabetically on the words. The output would also contain an output of the words sorted by frequency count For each word that is read, we will convert the characters to lower case [so that The and the are counted together and remove punctuation. The provided wordcollection class does this work for you. You can use a binary tree, sorted on the words, to hold the words and their counts, use the frequency class to make life easier. If a word is seen again, increment the count. I want you to utilize bintree.h to assist in creating and working with the tree. All output of the tree should utilize the inorder, preorder, or postorder convenience traversal functions