Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work.

Size: px

Start display at page:

Download "Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work."

Mildred Ball
5 years ago
Views:

1 It is most beneficial to you to write this mock midterm UNDER EXAM CONDITIONS. This means: Complete the mock final in 170 minutes. Work on your own. Keep your notes and textbook closed. Attempt every question. After the time limit, go back over your work with a different colour or on a separate piece of paper and try to do the questions you are unsure of. Record your ideas in the margins to remind yourself of what you were thinking when you take it up at PASS. The purpose of this mock exam is to give you practice answering questions in a timed setting and to help you to gauge which aspects of the course content you know well and which are in need of further development and review. Use this mock exam as a learning tool in preparing for the actual exam. Please note: Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work. Often, there is not enough time to review the entire exam in the PASS workshop. Decide which questions you most want to review the Facilitator may ask students to vote on which questions they want to discuss in detail. Facilitators do not bring copies of the mock exam to the session. Please print out and complete the exam before you attend. Facilitators do not produce or distribute an answer key for mock exams. Facilitators help students to work together to compare and assess the answers they have. If you are not able to attend the PASS workshop, you can work alone or with others in the class. Good Luck writing the Mock Exam!! Dates and locations of mock exam take-up: Saturday, Dec. 9th, 2-4pm, ME 3275 Monday, Dec. 11th, 4-6pm, ME 3275

2 Question 1 typedef struct { int size; intnode_t *tail; cool_intqueue_t; What is cool about the cool_intqueue_t above? What distinguishes it from a normal intqueue_t? Draw a picture of what a cool_intqueue_t looks like after enqueueing 3 nodes: enqueue(q, 3); enqueue(q, 2); enqueue(q, 1); Question 2 Write the normal intqueue_t struct definition (the one we have predominantly used in class), and a constructor function that returns a pointer to an empty queue. typedef struct { intqueue_t *intqueue_construct(){ intqueue_t;

3 Question 3 What three main cases do you need to consider when removing a node (using dequeue) from a Queue? a) head, tail, and current b) removing first element, removing last element, removing in the middle c) queue is empty, queue has one element, queue has more than one element Question 4 Draw an execution diagram of the following code, in the style of the factorial example below. Recurse down to the base case before returning back up the stack, crossing off the popped frames as you go. What is the value of result after recursivefn(7) returns? recursivefn(int n){ if (n < 2) return n; return n + recursivefn(n-2); int main(){ int result = recursivefn(7);

4 Question 5 We often have to use a loop to "traverse" toa certain element in a linked list. For which of the following linked list operations would you stop traversing when cur->next->next is NULL? ie. a while loop version would look like: while (cur->next->next!= NULL) { cur = cur-> next; a) Removing the last node b) Removing the second last node c) There's no good reason to do this. d) Checking if there are 3 elements in a list. Question 6 Each of the following code blocks, taken from culearn, has somehow been broken. There will only be one line that is either missing, in the wrong place, or just wrong. Make sure to consider all possible cases that could lead to failure. // this is the node type we use in our linked lists typedef struct intnode { int value; intnode_t *next; intnode_t; // returns a pointer to a new node initialized with the arguments passed in intnode_t *intnode_construct(int value, intnode_t *next) { intnode_t *ptr = malloc(sizeof(intnode_t)); ptr->value = value; ptr->next = next; return ptr; intnode_t *addfront(intnode_t *head, int value) { intnode_t *new_head = intnode_construct(value, NULL); return new_head;

5 // gets the length of a linked list. ie. empty list has length 0. int length(intnode_t *head) { int count = 0; for (intnode_t *cur = head; cur->next!= NULL; cur = cur->next) { count += 1; return count; // adds to the end of a linked list intnode_t *append(intnode_t *head, int value) { intnode_t *current; for (current = head; current->next!= NULL; current = current->next) { current->next = intnode_construct(value, current->next); return head; // returns the index of an element if it exists in the list int index(intnode_t *head, int target) { int i = -1; for (intnode_t *cur = head; cur!= NULL; cur = cur->next) { if (target == cur->value) return i; i += 1; return -1; // remove first node from the head and "returns" value in popped_value intnode_t *pop(intnode_t *head, int *popped_value) { assert(head!= NULL); *popped_value = head->value; free(head); intnode_t *new_head = head->next; return new_head;

6 Question 7 Draw the above linked list, in the same style, after running enqueue(q, 5). Assume that the enqueue function is correctly implemented for a linked list queue as we have seen in class. So after the function has run, we have enqueue'd (added) a new node with the value 5. After enqueue(q, 5) has finished, we run dequeue(q) 4 times. Draw the list after the dequeue's. Question 8 You have a singly linked list with no tail pointer. Including the head pointer you've passed into the function, how many pointers are required for: a) removing the first node (at the head) of the linked list? b) adding a node at the head of the linked list? c) removing the last node of the linked list? d) adding a node at the end of the linked list?

7 Question 9 Write the following short functions. Your answers should be at most 4 lines. Assume that the following function is properly defined and returns a pointer to a new node: intnode_t *intnode_construct(int value, intnode_t *next); // create a new node and add it to the front of a linked list intnode_t *addtofront(intnode_t *head, int value) { int recursivefactorial(n) { // given n, return n*(n-1)*(n-2)*...*1 // initialize an array a of length n with values between 1 and n void initarray(int *a, int n){ // you must use a walking pointer // initialize an array a of length n with values between 1 and n void initarray(int *a, int n){ // you must use recursion (loops)

8 // swap the values pointed to by the arguments x and y void swap(int *x, int *y){ Given int a and int b how would you call the above swap function so as to swap their values? Question 10 Recall: For an operation to be O(n), its running time depends on the length of the list, while the running time of a O(1) operation is the same for a small or large list. One of these statements about O(n) vs O(1) is correct: a) Removing from the head of a linked list takes O(n) time. b) Adding to the head of a linked list takes O(n) time. c) Removing from the tail of a linked list takes O(1) time (when you have a tail pointer.) d) Adding to the front of an array takes O(1) time. e) Using a linked list, a stack is O(1) but a queue is O(n) for adding and removing. f) Using a linked list, both stacks and queues can be O(1) for adding and removing. Question 11 Given a working constructor for a node with the following function prototype: intnode_t *intnode_construct(int value, intnode_t *next); On the next page, write a function to find a node whose value matches the value passed into the function, and remove that node. If the value is not in the list, or the list is empty, just return the head pointer. You can stop after finding one value - don't worry about multiple values. Make sure to consider all possible cases: 1. The list is empty. 2. The value is not in the list. 3. Remove first node. 4. Remove middle node. 5. Remove last node.

9 // fill in the rest of the function intnode_t *removeonevalue(intnode_t *head, int value) {

10 Question 12 Which of these statements about linked lists is correct? a) A complete list implementation can implement a queue. b) A complete queue implementation can implement a list. c) A complete queue implementation can implement a stack. d) A queue removes items on a LIFO (last in, first out) principle e) A stack removes items on a FIFO (first in, first out) principle. Question 13 On the next page, draw a C tutor style memory diagram of the following program state, just before main returns. We have access to the same intnode_construct function as in Question 7. #include <stdlib.h> typedef struct n { int value; struct n *next; intnode_t; intnode_t *intnode_construct(int value, intnode_t *next){... int main(){ intnode_t *head = intnode_construct(5, NULL); intnode_t *temp; head = intnode_construct(2, head); head->next->next = intnode_construct(17, NULL); int size = 0; for(temp = head; temp!= NULL; temp = temp->next){ size++; head->next->next->next = head; temp = head->next; free(head); head = temp; return 0;

11 Question 14 Given the following intlist struct and add function, write a function to double the capacity. typedef struct { int size; int capacity; int *elems; intlist_t; void addtolist(intlist_t *list, int x) { if (list->size == list->capacity) doublecapacity(list); list->elems[list->size] = x; list->size++; // fill in the rest of the function void doublecapacity(intlist_t *list) {

12 Question 15 Why have we not seen any structname.member notation in this mock exam? (ie. pt.x=0; pt.y=0;) Question 16 Given the following code: int *a; int x = 0; int *b; int y = 5; a) What is the name of the variable on the first line? What is its type? b) How do we assign the address of the variable on the second line to the variable on the third? c) How do we assign the value of the variable on the second line to the variable on the fourth? d) How do we assign the value of the variable on the second line to the variable on fourth, without ever putting y and x in the same line of code? (no using numbers, either) Question 17 (bonus) Recall that recursion involves base cases and recursive cases - see Question 4. The removeonevalue function from Question 11 can be expressed in terms of these cases: Base case 1: List is empty. We can't remove anything from it, so we just return NULL. Base case 2: First element in the list matches our value to remove. Remove it. Recursive case: First element doesn't match our value, but if we run removeonevalue on the rest of the list, we still might find it! On the next page, write the removeonevalue function recursively.

13 // fill in the rest of the function intnode_t *removeonevalue(intnode_t *head, int value) {

SYSC 2006 CD. Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work.

SYSC 2006 CD. Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work. It is most beneficial to you to write this mock midterm UNDER EXAM CONDITIONS. This means: Complete the mock final in 180 minutes. Work on your own. Keep your notes and textbook closed. Attempt every question.