a. vector
     b. list
     c. deque
     d. map
     e. set
     f. multimap
     g. multiset
     h. hash table

• a You want to get the distribution of exam scores by counting the number of exams in the range 0-9, 10-19, 20-29, ..., 90-100. You are guaranteed that the exam scores range from 0-100.
• h You have a test bank of questions and you want to ensure that the test-taker is never presented the same question twice. You decide you want to store the questions that the test-taker has seen. You do not need to keep the questions in sorted order. The two operations you need to perform are insert to insert a question that has been presented to the test-taker and find to determine if a question is in the data structure. You may assume that each question is identified by a unique label.
• c You are implementing a router for the internet which receives packets from various locations and transmits them to other locations. As packets arrive they should be placed at the end of the "line" and packets should be removed from and transmitted from the front of the "line".
• f You are implementing a diary program that stores dates and locations that the diarist visited on that date. The values are kept as (date, location) pairs. It is important to keep the dates in chronological order and a person may visit multiple locations on the same dates (hence there could be multiple pairs that start with the same date).
• a You want to reverse the lines in a file by storing the lines in the same order they are stored in the file (i.e., add each line to the back of the data structure) and then traversing the data structure from back to front once you finish reading all the lines from the file.
• b You want to implement a to-do list where the user can both add and delete items in arbitrary places in the list. The to-do list is not kept in any type of order.
• d You are keeping track of the number of times that each IP (internet) address has accessed your web-site. Each time an IP address accesses your web-site, you access that address in your data structure and increment its count by 1. You decide that it is important to keep the IP addresses in sorted order so that you can perform range queries on them. Each IP address is unique.

     string a, b;
     string *x, *y;

     a: 0x1000
     b: 0x1100
     x: 0x1200
     y: 0x1204
 

       Code Segment 1
       x = &b;
       *x = "Smiley";
       y = x;
       *y = "Brad";
       b = *x;

       Code Segment 2
       x = new string("Michelle");    // address of new string = 0x2000
       a = *x;
       y = new string("Charles");     // address of new string = 0x2100
       x = y;
       b = *x;

       Code Segment 1                 Code Segment 2
       
       a: ""                                 a: Michelle


       b: "Brad"                           b: Charles


       x: 0x1100                             x: 0x2100


       y: 0x1100                             y: 0x2100


                                            *x: Charles


                                            *y: Charles

class Picture {
public:  
    ifstream *sourceFile;
    int rows;
    int cols;
};

Picture *p;
string *name1, *name2;

name1 = new string("Hank Aaron");
name2 = name1;
delete name1;
p = new Picture();
p->sourceFile = new ifstream();
p->rows = 30;
p->cols = 40;
*name2 = "Hammerin Hank Aaron";
p->sourceFile->open("mountain.jpg");

Answer the following questions about the above code:

1. dangling pointer This term is used to describe what name2 becomes after name1 is deleted.

2. What is likely to happen when p->sourceFile->open is executed and why is it likely to happen? Use no more than 3 sentences for your answer.

   The most likely result is a seg fault because there is a good chance that name2 points to the same memory as p and hence the string "Hammerin Hank Aaron" has overwritten the memory pointed to by p. In particular, the memory address in p->sourceFile has been overwritten with random characters and therefore is likely to no longer represent a valid memory address. When you try to access an invalid memory address, you get a seg fault.

   The other less likely result is that when p->sourceFile was overwritten with random characters, the memory address was a valid one but instead of this memory address being the ifstream that was allocated, it is a random memory address. Since p->SourceFile no longer points to the ifstream object, it is hard to predict what will happen but at the very least, the open function will not get called. There is also a good chance that a seg fault will happen because it is unlikely that the memory address to which p->SourceFile points is a valid function address.

• For the list and vector, assume that new telephone numbers are always added to the beginning of the data structure.
• For the hash table give me the average case running time.

Here is the rationale for each of the answers:

• map: Each insert/find takes O(log n) time and since there are n such operations, the total time is O(n log n) for each of them.
• hash table: Each insert/find takes O(1) average time and since there are n such operations, the total time is O(n) for each of them.
• list: Inserts at the beginning of a list take O(1) time. Since there are n inserts, the total time for the inserts is O(n). Each find must potentially search the entire list, which requires O(n) time, and since there are n find operations, the total time for the finds is O(n²).
• vector: Inserts at the beginning of a vector take O(n) time because all the existing elements in the vector must be moved one element to the right. Since there are n inserts, the total time for the inserts is O(n²). Each find must potentially search the entire vector, which requires O(n) time, and since there are n find operations, the total time for the finds is O(n²).

      Brad VanderZanden
      Smiley VanderZanden
      Minnie Mouse
      Mickey Mouse
      Ebby VanderZanden
    

  typedef set <string> fnset;

  map <string, fnset> lnames;
  string fn, ln;
  fnset firstnames;

  while (cin >> fn >> ln) {
     firstnames = lnames[ln];
     firstnames.insert(fn);
     lnames[ln] = firstnames;
  }
    

1. Explain why the following code is inefficient (it computes the correct result but is inefficient). Use no more than 3 sentences to describe the problem.

   The line firstnames = lnames[ln] makes a copy of the set associated with ln. The next line inserts into this copy and the final line copies this copy back into the original set. Making copies is expensive and should be avoided if possible.

2. How could you rewrite the code to fix the inefficiency. Only modify that portion of the code that needs to be changed.

   You can fix the inefficiency by avoiding the copy and modifying the original set instead. This can be done in two ways.

   1. Replace the three statements with the following one:

      lnames[ln].insert(fn);
      		

      This statement modifies the return value of lnames[ln] and C++ does not make a copy of the return value. It modifies the original value which in this case is the first name set associated with ln.

   2. Make firstnames be a reference variable:

      fnset &firstnames = lnames[ln];
      firstnames.insert(fn);
      lnames[ln] = firstnames;
      		    

      The reference variable points to the original set and no copy gets made.

class Person {
public:
  string name;
  Person *bestFriend;

  Person(string n) { name = n; }
};

string names[] = { "mickey", "bugs", "daffy", "winnie" };
list<Person *> friends;
Person *newPerson;
Person *lastPerson;
int i;

lastPerson = NULL;

for (i = 0; i < 4; i++) {
    newPerson = new Person(names[i]);
    newPerson->bestFriend = lastPerson;
    friends.push_back(newPerson);
    lastPerson = newPerson;
}

• You draw the sentinel nodes for the list
• You show the objects to which newPerson and lastPerson point.
• You show the objects to which the bestFriend pointers point.
• You show the objects to which each list node points