array     singly-linked list     linked-list queue       linked-list stack
          doubly-linked list     circular array queue    array stack

For each of the following questions choose the best answer from the above list. Assume that the size of an array is fixed once it is created, and that its size cannot be changed thereafter. Sometimes it may seem as though two or more choices would be equally good. In those cases think about the operations that the data structures support and choose the data structure whose operations are best suited for the problem. You may have to use the same answer for more than one question:

1. linked-list queue The data structure you would use if you were writing software for a call center that ensured that calls are answered in a first-in, first-out order. You should assume that you have to be able to store an unlimited number of waiting callers.
2. linked-list stack The data structure you would use if you wanted to store different purchase lots of an inventory item (e.g., printers) and when you sold them, you want to decrement the remaining quantity of the most recently purchased lot. For example, if you make 3 separate purchases of 20, 30, and 15 printers, and you then sell 5 printers, you want to decrement the lot of 15 printers so that it is now 10.
3. array The data structure you would use if you had a pre-sorted set of data with a known size and you wanted to use binary search to find whether or not certain keys existed in the data (in binary search you probe into the middle of the remaining data and then eliminate either the bottom or upper half of the data depending on the value of your key and the value of the element at the middle of the data).
4. circular, array queue The data structure that you would use in a router to store and dispatch an incoming set of message packets from the network if you have a limited amount of memory to store the packets (packets that cannot be stored because there is not enough memory will be bounced back to the sender). Packets should be dispatched to the next router in the network in the order in which they are received.
5. singly-linked list The data structure that is easiest to use if you need to read and store an unknown number of data items, and subsequently search this data structure for different keys.

typedef struct {
  int x;
  char name[20];
  char *address;
} FriendRecord;

FriendRecord *friend;
void *ptr;
char input[20];

1. friend = ptr; illegal: you need to use a downcast to assigned an untyped pointer to a typed pointer
2. ptr = friend; legal: it is okay to assign a typed pointer to an untyped pointer
3. ptr->x = 20; illegal: even if ptr points to a FriendRecord, this operation is illegal because an untyped pointer does not have a known type and hence you cannot access any member fields through an untyped pointer.
4. strcpy(friend->name, input); legal
5. friend->name = strdup(input); illegal: you cannot assign a new pointer value to a statically declared character array.

O(n³): the most time is spent in the three nested loops. Each loop iterates n times, and each iteration of the inner-most loop requires a constant amount of time.

(a) min = -1; for (i = 0; i < n; i++) { if (a[i] < min) min = a[i]; } printf("min = %d\n", min);	(b) a = 10; b = 20; c = a + b;
(c) for (i = 0; i < n; i++) { if (array[i] > 0) { sum = 0; for (j = i; j < n; j++) { sum += array[j]; } printf("sum = %d\n", sum); } else printf("array[%d] = %d\n", i, array[i]); }

1. O(n): There is one for loop that iterates n times and each iteration requires a constant amount of time.
2. O(1): There are three constant time statements executed in consecutive order, and hence their time is additive, and constant.
3. O(n²): There is one outer loop that iterates n times. Each loop iteration is dominated by the conditional, which in the worst case always chooses the true branch. The for loop in this branch iterates n times in the worst case and each iteration requires a constant amount of time. Hence the true branch requires O(n) time, and hence each iteration of the outer loop requires O(n) time. The overall time is therefore O(n*n) = O(n²).

1. Which program has the better guarantee on the running time, for large values of N (N > 10,000)? Why?

   B: For large values of N, 1000N² < 2^N

2. Which program has the better guarantee on the running time, for small values of N (N < 10)? Why?

   A: For N < 10, 2^N < 1000N²

3. If you did not know the size of the input, which program would you prefer? Why?

   B: If you do not know the size of the input, you must assume the worst case, which is that it will be fairly large. In that case we prefer the program with the better big-O running time, and that is B.

struct node {
  void *value;
  struct node *next;
}; 
struct node *my_node, *successor;

      Before:        ___________      _____________
               <-----| my_node |<-----| successor |<-----
               ----->|         |----->|           |----->
                     -----------      -------------

      After:         _____________      _____________
               <-----| successor |<-----| my_node   |<-----
               ----->|           |----->|           |----->
                     -------------      -------------
      

          _____________   5  ___________   2  _____________   3  _____________
          | prev_node |<-----| my_node |<-----| successor |<-----| last_node |
          |           |----->|         |----->|           |----->|           |
          -------------   1  -----------   4  -------------   6  -------------

        struct node *prev_node = my_node->prev;
        struct node *last_node = successor->next;

        1) prev_node->next = successor;
        2) successor->prev = prev_node;
        3) last_node->prev = my_node;
        4) my_node->next = last_node;
        5) my_node->prev = successor;
        6) successor->next = my_node;
        

3 2 + 4 * 3 5 * + 

1. What is the contents of stack after the second * is read and processed? Some of your entries may be empty. Fill the stack from bottom to top:

        ______________
        |            |
        |            |
        --------------
        |            |
        |            |
        --------------
        |            |
        |            |
        --------------
        |            |
        |    15      |
        --------------
        |            |
        |    20      |
        --------------
   

2. Once mystery has read the full input, what does mystery return? 35
3. Suppose the input were instead 3 2 + 4. What would mystery return in this case? -2
4. Suppose the input were instead 3 2 + *. What would mystery return in this case? -1
5. mystery returns three different values--result, -1, or -2--depending on the outcome of its checks. How would your calling program interpret each of these return values? That is, if your program had to print a message explaining the meaning of the return value, what would it say. Be concise (you may want to defer this question to the end of the test because you might have to devise a couple sample input sequences to figure it out and that could take some time).
   1. -1: Too many operators
   2. -2: Too many operands
   3. result: The value of the postfix arithmetic expression

L1: (6, 8, 10, 20, 25, 30, 41, 66)
L2: (3, 6, 10, 33, 38, 41, 55, 66, 78, 90)

L1: (8, 20, 25, 30)

Here is some helpful information:

1. L1 and L2 are pointers to Dllists.
2. Assume that dll_val returns an int and not a void *. Hence dll_val(node) will return the integer value of that node.
3. The function does not return anything nor does it print anything. It achieves its result by modifying the two lists.
4. For maximum points, you should take advantage of the fact that the elements of L1 and L2 are sorted in ascending order and traverse each list only once. If you cannot figure out how to do this, you can traverse L1 and L2 multiple times for 16 points.
5. You need to show me your function declaration and definition. Do not show me include files, statements to read data, etc. Assume L1 and L2 have been created for you by the calling function.