The structures to be implemented in the context of work are 1) Unacceptable table, 2) Classified Table, 3) Simple Binary Search Tree, 4) AVL type Binary Tree and 5) A fragmentation table with an open address.
These structures should store the different words of the text and the plurality of appearances of each word within the text. We assume that a word L1 is less than a word L2 when L1 lexicographic is found before the word L2. For example, "That" <"This", "Apple" <"Cat", "Over" <"Under", etc. Your work will be tested with files of size corresponding to the previous one. So you should do the necessary tests so that your code is working properly.
For each structure, there should be a .h that should be #include from the program that wants to use the corresponding structure. Also, for each structure, there should be at least one .cpp file that implements the corresponding structure. Your program will not read anything from the keyboard. When the program is executed you should initially build data structures by inserting the words one by one as we read the file lines. From the text file, it must be randomly selected a set Q e.g. 1000 words (not necessarily different) which will be used to carry out searches in the structures we have implemented. Then we look for all the words of the set Q in each structure and return the corresponding total time (how much time the structure to answer the queries) as well as how many times each word is displayed. Obviously, for every word we seek, the structures should give the same effect as to the crowd of appearances but a different run time.
The construction of structures and search will be done by main () which must call the appropriate methods from the classes that implement the structures. Also, your program should support structures: Introduction, Delete, Search, Inder, Preorder, Postorder. For the fragmentation table, only import and search are required (not delete). It is also noted that when we work with text, we often run some pretreatment. For example, we often convert upper case capital (because e.g. the word "this" is the same as the word "THIS") and remove punctuation marks. These two features should be performed by your code when reading the input file. In the report, you will deliver you should explain how to design and implement your app and generally give the information you consider necessary. Also, your Code should contain sufficient comments.
I need some help with the AVL type Binary Tree and the fragmentation table with an open address cuz not so good with these.
The length of my tables and trees is determined by the Q but is it changing if I choose more words from the text file, so I have to change the length every time?
this is a total gem:
There should be a .h that should be #include from the program that wants to use the corresponding structure for each structure.
Did your professor by any chance fail out of law school before taking up programming? I unfortunately read in paragraphs and since there is only one I ended up soaking up the whole thing. Ouch.
Oh, and welcome to the forum. I didn't see any code there, nor any questions, but what looks like an unformatted copy and paste of schoolwork. Did you mean to ask a question and post some code? You can edit the above post to put your code sample in and explain what you needed help with.
What's an "unacceptable table" or "classified table". And later on, "Calm Structures". This seems to have been run through a translator. (Except strangely the last few sentences.)
It seems he needs to create 5 different data structures for the same task:
1. unordered array/vector (?) "unacceptable table"
2. ordered array/vector (?) "classified table"
3. binary search tree (unbalanced)
4. AVL tree
5. hash table
Show what you've done so far. Remember to use code tags when posting code: