Test 1 SOLUTIONS. June 10, Answer each question in the space provided or on the back of a page with an indication of where to find the answer.

Transcription

1 Test 1 SOLUTIONS June 10, 2010 Total marks: 34 Name: Student #: Answer each question in the space provided or on the back of a page with an indication of where to find the answer. There are 4 questions on this exam, which consists of 6 pages. If you wish to make reference to some function that is not explicitly given, you must provide the code for that function (standard C++ functions excepted). When dynamically allocating space for a new Node in a linked list, you can ignore the possibility of running out of memory. For questions involving linked lists, you may assume the following definition of Node: class Node { public: int info; Node *next; Node(int el, Node *ptr = 0) { info = el; next = ptr; ; See the following page for useful formulae. 1

2 Useful formulae: Definition of big-o notation: Given two positive-valued functions f and g, f(n) is O(g(n)) if there exists positive numbers c and N such that f(n) cg(n) for all n N. Fact 1 If f(n) is O(g(n)) and g(n) is O(h(n)), then f(n) is O(h(n)). Fact 2 If f(n) is O(h(n)) and g(n) is O(h(n)), then f(n) + g(n) is O(h(n)). Fact 3 The function an k is O(n k ). Fact 4 The function n k is O(n k+j ) for any positive j. Fact 5 If f(n) = cg(n), then f(n) is O(g(n)). Fact 6 The function log a n is O(log b n) for any positive numbers a and b 1. Identities: 1 = n i = n(n + 1) 2 2

3 Q1 [6] (a) [2] Consider the definition of the Node class on page 1. Would you consider this class to be an abstract data type? Explain why or why not. Write your answer in 1-3 sentences. The Node class cannot be considered an abstract data type because it does not hide its data (i.e. info) from its users. This follows from the fact that info is public. (b) [4] Consider the following member function declaration for a class called BankAccount which has an int called balance: void withdraw(int amount); // Precondition: The amount to withdraw is no greater than the current // balance. // Postcondition: The balance is reduced by amount. For each of the following implementations of withdraw indicate whether the implementation meets the specification or not (write yes or no next to each one): void BankAccount::withdraw(int amount) { if (balance < amount) balance = 0; else Yes. While the implementer has opted to cover a case not handled by the precondition, this has no bearing on the adherence of this function to the given specification. void BankAccount::withdraw(int amount) { if (balance < amount) No. If the precondition is true this implementation does nothing at all. 3

4 void BankAccount::withdraw(int amount) { Yes. Here we didn t bother to check the precondition. Nevertheless, if the precondition holds, the postcondition will hold. void BankAccount::withdraw(int amount) { if (balance >= amount) Yes. This is perhaps the most natural implementation (although we might want to do something else if the precondition doesn t hold). 4

5 Q2 [10] Complete the function sortedinsert below which inserts a new node into a singly-linked list such that the list remains in sorted order. Your code should handle all conceivable special cases. Be sure to update both the head and tail pointer of the list. // Precondition: If the list is not empty, it is sorted in non-decreasing // order (this means that the list may be empty). void SLL::sortedInsert(int el) { if (head == 0) { head = new Node(el); tail = head; else if (head->info > el) { head = new Node(el, head); else { Node *prev = head; Node *cur = head->next; for ( ; cur!= 0 && cur->info < el; prev = prev->next, cur = cur->next) ; prev->next = new Node(el, cur); if (cur == 0) tail = prev->next; 5

6 Q3 [9] (a) [2] Give the asymptotic complexity of the following functions in big-o notation. Your answers should be in the smallest and simplest possible terms: f(n) = lg n 2 + 3n n O(n 2 ) f(n) = n log 10 n + log 4 n n O(n lg n) (b) [3] Prove the following using only the definition of big-o notation: 4n + 2n 3 is not O(n 2 ) To show that this function is not O(n 2 ) we must show that there are no constants c and N that can satisfy the following: 4n + 2n 3 cn 2, n N We solve for c, 4 n + 2n c No constant c can satisfy this equation because n grows without bound. Thus, 4n +2n 3 is not O(n 2 ). (c) [4] Prove the following: n lg i is O(n lg n) To show that this function is O(n lg n) we must show that there exists constants c and N that satisfy the following: f(n) = lg i cn lg n, n N If another function g(n) can be found such that f(n) g(n) then f(n) is O(g(n)). Further, if g(n) can be shown to be O(n lg n) then it follows that f(n) is also O(n lg n) by transitivity (i.e. fact 1). Let, g(n) = lg n It is clear that f(n) g(n) because we have merely replaced i with n, and we know that lg i lg n since the lg function is monotonic and i n. It remains to show that g(n) is O(n lg n). To show this we first simplify g(n), g(n) = lg n = lg n 1 = n lg n Clearly, g(n) = n lg n is O(n lg n) by fact 6 (with c = 1). Therefore f(n) is also O(n lg n). 6

7 Q4 [9] (a) [4] Determine the exact number of assignment statements executed by the code snippet below. You may assume that n is even. Also give the asymptotic complexity in big-o notation: for (i = 0; i < n/2; i++) for (j = 0; j < n*n; j++) a[i][j] = i * j; We have one statement that is executed regardless of n (i = 0). Also, in the body of the outer loop we have two statements which are executed once for each iteration of the outer loop. The body of the outer loop executes n/2 times so this gives another n statements. Within the body of the inner loop there are also two assignment statements. They are executed n = n 2 times per iteration. There will be n/2 iterations of the outer loop. Thus, the total number of assignment statements executed is: n 3 + n + 1 Parts (b) - (c) relate to the following code snippet: for (i = 0; i < n; i++) { b[i] = 0; for (j = 0; j < n; j++) { if (a[j] < 0) b[i] += a[j]; (b) [1] What is the worst-case value of the input array a? All entries of array a are negative. (c) [4] Determine the exact number of assignment statements executed in the worst-case. In the worst-case, the condition of the if statement is always true. Therefore, b[i] += a[j] is executed the same number of times as j++. Statements Executions i = 0 1 i++ n b[i] = 0 j = 0 j++ n 2 b[i] += a[j] Thus the total number of assignment statements executed is 1 + 3n + 2n 2. 7