C/C++ Alphabetical Linked List

Question

For my programming class, we have to create a linked list, which is arranged in order of when you added them. This was Assignment Six. Assignment 8 is to add an alphabetical list to this program, alongside the list in order.
My professor wants us to have a "donor struct" and an "alpha struct" that points to the donor, as well as the next in the list.
He isn't helping me figure this out so I figured I'd ask for help here.
My 'modifyDonor()' function is broken, it deletes everything after whatever record you are trying to modify. There is also a problem in my 'prepareFiles()' function. Whatever the last entry is, is copied in twice.
I would rather have this alphabetical stuff figured out before I work on those things.
I'm not really allowed to use C++ stuff (classes, objects, etc.), because we haven't learned them yet, but if you can do it, and figure it out, then explain it to me. I'll take it.
(Also, if you could post the edits to my source code, that would rad!)
Below is a link to my source code and data file.
http://www.dcpwrpodcast.com/DCPWR/Help.Sponsorhipfiles/Archive.zip
Any help you can provide is greatly appreciated!

Answer 1

Unfortunately, I can't really pinpoint an exact place where you are doing something wrong. I don't think you really understand the linked list concepts yet. The first thing I changed was getting rid of where you increment "first" in modifyDonation. Resetting "first" effectively destroys your list. You have additional problems with the other pointers.
So, first of all, you have too many global pointers. You need one global pointer, named "head". Any time you iterate through the list (to print, find, etc.) you create a temp donor pointer, assign "head" to it and increment that temp pointer. The last node in your list should have NULL as its "next" pointer.
To add a node, create a new node with NULL as its next pointer. Find where you want to insert, make the new node's next pointer point to the next pointer of the node at the insertion point. Then make the next pointer of the node at the insertion point point to the new node.
To delete a node, find the node to delete. Make the previous node's next pointer point to the dead node's next pointer. Then delete the node.
You don't change any pointers (other than temp ones) during a modify or print.
At this point, all you have left is the special case of the first node. The last node isn't special because you can do the same copying of the next pointer as normal, even though that pointer is NULL.
The first node, however, needs careful handling. If you delete the first node, you have to reset your head pointer. If you insert a new first node, you have to reset your head pointer. Sometimes it is easier to have your head node be a special, empty node. Then, you don't have to re-assign head. Also, when searching through the list, your "current" pointer should be the "previous" node. That way, when you are ready to insert, your "current" pointer is the "previous" node and the insertion is easy. The code looks a bit ugly because you'll have things like "if(current->next && current->next->id == id)". But you'll also need an extra, redundant null check.
Hopefully this makes some sense. Your code is more complicated than it needs to be. You have too many globals. You are modifying those globals far too frequently. You want lots of:
void modifyDonation(donor * node);
donor * current = head->next;
while(current)
if(current->id == id)
modifyDonation(current);
break;
current = current->next;
insert and delete are more difficult
void insertDonation(donor * previous, donor * next);
donor * current = head;
while(current)
if(!current->next || (current->next->id == id))
insertDonation(current, current->next);
break;
current = current->next;
To maintain a natural order and a sorted order, you'll need two head pointers. After you add or insert into the natural list, you insert into the sorted list according to the sort criteria. Delete is the same for both lists.