Since we don't have a mechanism for you to get the critiques others write about you, you don't need to comment on critiques sent by others to you (at least not on P3). Just write the critiques for the two students you received by email and submit as told to you, and that should be fine.

It's possible that your executable has gotten very large. There's a limit set on how large a file you can create (should be 5M). There are two ways to solve this problem:

unlimit filesize

Another way is to avoid using the -g option. This is the debug option, and it makes your executable rather large. It's moderately depressing how large C++ executables are.

Sometimes the problem is that you exceed disk quota. If that's occurring, you need to remove executables, .o, core dumps, cxx_repository from previous projects. Even old input files can be rather large.

Yes, you may. There may be some problems with a constructor, and a warning on operator=.

Yes, make the changes for both MovieArrayListTester as well.

You should have received an email in your class account with instructions regarding which TWO proposals you should critique and how to submit them. To read email in your class account you can use the pine email program (type "pine" at the Unix prompt and follow the instructions).

An example email can be found in the class posting account in the following directory:

~bt14001/Projects/Proposals/

You must submit BstMap.h and BstMap.cpp with the rest of your project by Friday evening if you want BOTH the 7 point extra credit (up to 7 points, that is) and the early bonus. However, you can submit BstMap.h and BstMap.cpp (with the rest of your project), any time after that for up to 7 points extra credit.

You can not send them in separately. For example, you can't send in the project on Friday (for early bonus) without the BstMap.h and BstMap.cpp. (Some students want to send two versions....one without the two extra credit files to get the early bonus, then submit the two files and get the bonus).

Only one submission will be graded. (Note: you can choose not to implement the extra credit, of course).

The output BNF to the traversal, and the description in the BstSortedList have now been made to match (basically, I opted to make the output BNF the official).

There were many extra helper functions in the file that shouldn't have been there. You were supposed to come up with your own. So, they have been removed. You don't have to implement those helper functions. You can write your own.

In Task 10, you write "critiques" of other student's proposals. We're still waiting for submissions of all the projects, so the proposals will most likely be posted during Spring Break. This will give you the week after Spring Break to read three proposals and make comments on them.

The extra credit (which used to be Task 10) is now Task 11.

Good question! The answer is in the MovieBstSortedList specifications---about half way down.

There's a total of 12 points extra credit. 5 points for turning it in early (by Friday, April 5, 11 PM) and 7 more points for implementing BstMap class (which can be turned in at any time before the 3 days late).

TreeExercises.questions should be posted in the next day or so. In the meanwhile, start thinking about how to implement locate() and add(). You should definitely finish these two methods before Spring Break.

One possibility is to write a locate() which is not recursive now, and make it recursive later on.

One problem with developing add() is that it calls locate() so locate() should be implemented first. Yet locate() has nothing to locate if the BST is empty. It seems like a "chicken and egg" problem. How can you implement locate() method, when you need add() to create a tree? How can you implement add() when it requires locate() to do its work?

One answer is to write a method that will construct a "hardcoded" tree. This is how it might look:

void BST::hardcodeTree()
{
   Movie m1( "B" ) ;
   Movie m2( "C" ) ;
   Movie m3( "D" ) ;

   Node * node1 = new Node( m1 ) ;
   Node * node2 = new Node( m2 ) ;
   Node * node3 = new Node( m3 ) ;

   root = node1 ;
   node1->setRight( node2 ) ;
   node2->setRight( node3 ) ;

   node1->setSucc( node2 ) ;
   node2->setSucc( node3 ) ;

   node3->setPred( node2 ) ;
   node2->setPred( node1 ) ;
}

You need to dynamically allocate the Node, otherwise they will get destructed when the function exits.

To use this method, merely call bst.hardcodeTree() and this will construct a BST (you MUST be careful to construct it correctly). You can then call locate() and print out the values of the node pointed to by curr and parent to see if they point to the correct location.

You should draw several examples on paper, and corresponding pointers indicating where curr and parent should point. Hopefully, your paper version and your coded version will match.

Once you have written add(), you might try writing the copy constructor, assignment operator, and destructor (if needed), and then begin remove().

You will be in excellent shape if remove() is completed before Spring Break. You will be in reasonably good shape if you are ready to do remove once you return from Spring Break. The close you are to finishing remove(), the better off you are. Get it done sooner, rather than later.