CS32 Final Exam. E03, S15, Phill Conrad, UC Santa Barbara Tuesday, 06/08/2015, 8am 11am

Transcription

1 1 CS32 Final Exam E03, S15, Phill Conrad, UC Santa Barbara Tuesday, 06/08/2015, 8am 11am Please write your name above AND AT THE TOP OF EVERY PAGE Be sure you turn in every page of this exam. This exam is closed book, closed notes, closed mouth, cell phone off You are permitted one sheet of paper (max size 8.5x11") on which to write notes These sheets will be collected with the exam, and might not be returned Please write your name on your notes sheet READ THIS NOW: SERIOUSLY! Some of this exam will test what you have learned in familiar situations, while other parts will test your ability to apply what you leave learned in new situations. In particular, during the last lecture of the quarter, I briefly discussed QuickSort. I strongly hinted that while I would NOT ask you to recall specific details of QuickSort on the exam, I might very possibly give you an outline of QuickSort on the final exam, and then ask you to apply what you already know in light of this new information. So, this should not come as a surprise: the handout you got with this exam contains an outline of quicksort. Most of the questions on this exam pertain to quicksort in one way or another. 1. The first case study involves quicksort in the context of arrays. On one side of your handout, please find a listing of quicksort.hand review the function prototypes listed there. You will be asked to write portions of the code for some of these functions, so I encourage you to take a moment to get familiar with the "big picture" of this code before starting. 2. The second case study involves applying the ideas of quicksort to sorting linked lists. On the other side of your handout, please find a listing for the class LinkedList. Note that LinkedListhas a member function called sort. It also has function prototypes for the big three, and two private helper functions that will be used in both the big three, and in our implementation of quicksort for linked lists. When you get to those questions, take a few moments to look over that side of the handout. Ok! Let's get started!

2 2 1. (4 pts) Please refer to the handout with information about QuickSort. First, read through the material in the left column. Then look at the function prototypes in the right hand column. Find the function prototype for issorted. This function takes an array of size n and determines whether it is sorted or not. It is used as a helpful function in QuickSort. As you may recall from mergesort, the recursion can stops when the array is of size 0 or 1, since an array of size 0 or 1 is already "sorted". We can do better: if any size subarray is already sorted, we can avoid the work of all the recursive calls, and speed things up. The code for issorted is partially complete below. Please add only the missing lines to complete the code so that it works correctly, and runs in time O(n). NOTE: This code is tested, and works correctly on arrays of size 0, 1 and sizes greater than 1. You should be able to make it work by ONLY adding a correct condition in the if test. FOR FULL CREDIT, DO NOT ADD ANY OTHER CODE. Work within the framework given here. bool issorted(int *a, int n) { for (int i=0; i<n-1; i++) { if ( ) { return false; return true;

3 3 2. (4 pts) Another helper function we'll use in building quicksort is a function that counts the number of occurences of an item in an array. We use this to count how many times the pivot element occurs. Here, ais an array of size nand xis the value that we are counting occurences of. Fill in the body of the function numoccurencesbelow: int numoccurences(int *a, int n, int x) { int count=0; return count; // number of times value x occurs in array a

4 4 3. (4 pts) Yet another helper function we'll use in building quicksort is one that pulls out the elements smaller than the pivot into a separate array. This function has the prototype: int copylessthanpivot(int *a, int n, int pivot, int *dest); Here, ais the array we are copying from. The array ais of size n. The value pivotis the number we are comparing each element of awith, and destis an array that we are copying the new values into.. The return value is the number of elements copied into dest. int left[n]; int right[n]; int numleft = copylessthanpivot(a,n,pivot,left); int numright = copygreaterthanpivot(a,n,pivot,right); The code at right from our quicksort implementation shows how it is used, along with its companion function copygreaterthanpivot. We see that after calling copylessthanpivot, the valuiable numleftwill contain a count of the number of elements of the array athat were smaller than the value pivot, and the array leftwill contain those values in elements left[0]through left[numleft-1]. Fill in the two lines of code in copylessthanpivot. There are EXACTLY two missing lines of code. (Note that it is possible to combine them into one, but please don't do that.) Also note that copygreaterthanpivotwill be exactly the same except that it will have a > instead of a < symbol in the if test. int copylessthanpivot(int *a, int n, int pivot, int *dest) { int count=0; for (int i=0; i<n; i++) { if (a[i] < pivot) { return count;

5 5 4. (9 pts) Now quicksort is easy to build. The full implementation appears on page 12 of this exam, which you may want to refer to when answering this question, along with the outline on the handout. However, we still haven't written the code for the reassemblehelper function. An incomplete version of that function appears below. Fill in the missing three lines. Each blank gets exactly one assignment statement. void reassemble(int *a, int n, int *left, int nleft, int pivot, int pivotcount, int *right, int nright) { if (nleft+pivotcount+nright!= n) { throw std::invalid_argument("nleft + pivotcount + nright should sum t for (int i=0;i<nleft;i++) { for (int i=nleft; i<nleft+pivotcount; i++) { for (int i=0; i<nright; i++) { And with that, our implementation of quicksort is complete.

6 6 5. Now, before we move on to applying quicksort to linked lists, a half time feature: questions about operating systems and tools. a. (3 pts) Briefly: What is the purpose of an operating system? Answer in 8 words or fewer. b. (3 pts) Briefly: In the context of an operating system, what is a process? c. (3 pts) Briefly: In the context of Unix, what is a system call? d. (3 pts) Briefly: What is a memory leak? e. (3 pts) Briefly: What tool can help you locate a memory leak? f. (3 pts) Briefly: If you want to use gdb to debug a program, what should you add to CXXFLAGS in your Makefile?

7 7 6. We now turn our attention to the class LinkedListon the other side of the handout that came with your exam. Please first note that the member function addatheadand addattailadd elements to the list. Please fill in the missing lines of code in these functions below as they would appear in the linkedlist.cppfile: a. (4 pts) Fill in exactly ONE missing line of code in addathead: void LinkedList::addAtHead(int data) { Node *n = new Node; n->data = data; this->head = n; if (this->tail==null) this->tail = n; b. (8 pts) Fill in exactly TWO missing lines of code in addattail: void LinkedList::addAtTail(int data) { Node *n = new Node; n->data = data; n->next = NULL; if (this->tail==null) else { this->tail = n;

8 8 7. The big three are implemented using helper functions recycleallmemoryand addaddattail, as shown here: LinkedList & LinkedList::operator= (const LinkedList &right) { if (this!= &right) { recycleallmemory(); addallattail(right); return (*this); LinkedList::~LinkedList() { recycleallmemory(); LinkedList::LinkedList(const LinkedList &orig) { this->head=null; this->tail=null; this->addallattail(orig); Your job, of course, is to finish the implementations of these two functions. They are shown, in incomplete form, on the following page. Finish them, as indicated. a. (8 pts) Fill in the two blanks in addallattail void LinkedList::addAllAtTail(const LinkedList &orig) { for (Node *n= ; n!=null; n=n->next) { continued on the next page...

9 9...continued from previous page b. (8 pts) Fill in the two missing lines in recycleallmemory void LinkedList::recycleAllMemory() { Node *p = while (p!=null) { Node *d = p; p=p->next; this->head = NULL; this->tail = NULL; 8. (8 pts) Just as with the quicksort on an array, we will need a way of determining when a list is sorted. Please finish the following function which determines whether a list is already sorted. Be sure that it can run in time O(n), where n is the size of the list. Note that a list of size 0 is already sorted, as is a list of size 1. Be sure you function handles those cases, and does NOT segfault! FOR FULL CREDIT: Confine your answer to filling in only a single line of code in the first blank, and filling in the condition of the for loop. There may be other ways of solving it, but there is a way to solve it in this form, and for full credit, you need to come up with it. bool LinkedList::isSorted() { if (this->head == NULL) for (Node *n=this->head; ; n=n->next) { if (n->next->data < n->data) return false; return true;

10 10 9. (9 pts) Now, we should be able to use the helper functions already written to put together a quicksort for a linked list. Fill in the missing pieces. void LinkedList::sort() { if (this->issorted()) { return; int pivot = this->head->data; LinkedList left; LinkedList middle; LinkedList right; for (Node *p=this->head; p!=null; p=p->next) { if (p->data < pivot) { left.addattail(p->data); else if (p->data == pivot) { middle.addattail(p->data); else { right.addattail(p->data); left.sort(); right.sort(); // FILL IN THE PARAMETERS this->recycleallmemory(); this->addallattail( ); this->addallattail( ); this->addallattail( );

11 (4 pts) In the implementation of LinkedList::sort, we find this line of code: int pivot = this->head->data; Suppose your pair partner were concerned that this->head->datamight produce a segmentation fault due to this->headbeing a null pointer. Write a short, but convincing arrgument (based on the implementation of the functions you have given on this exam) to reassure your pair that this cannot happen. 11. In the member function LinkedList::sort, we see that left,middle,and rightare declared as local variables. a. (3 pts) Will they be stored on the stack or the heap? b. (3 pts) What about the Nodestructs that make up the linked lists that headtail inside each of left,middle,and right: are these on the heap or the stack? 12. For a LinkedListobject representing a list of size n: a. (3 pts) What is the best case running time for the member function sortin terms of big O notation? NOTE: I said best case, not worst case. Be careful! b. (3 pts) Explain your answer to the previous question.

12 12 The final implementation of quicksort for questions 1 through 4 (on pages 2 through 5): void quicksort(int *a, int n) { if (issorted(a,n)) return; int pivot=a[0]; int pivotcount = numoccurences(a,n,pivot); int left[n]; int right[n]; int numleft = copylessthanpivot(a,n,pivot,left); int numright = copygreaterthanpivot(a,n,pivot,right); quicksort(left,numleft); quicksort(right,numright); // copy back into a: all elements from left, // then pivotcount copies of pivot, // then all elements from right reassemble(a,n,left,numleft,pivot,pivotcount,right,numright); End of Exam total points=100