CS-141 Exam 2 Review April 4, 2015 Presented by the RIT Computer Science Community

Transcription

1 CS-141 Exam 2 Review April 4, 2015 Presented by the RIT Computer Science Community Linked Lists 1. You are given the linked list: You may assume that each node has one field called value and one called next. (a) 1 points to 2 and 2 points to 3. What does 3 point to? The implementer may cause the 3 node to point to either None or a sentinel node. (b) Draw out the linked list structure and add a 5 to the end value: 1 value: 2 value: 3 value: 5 next: > next: > next: > next: None OR value: 1 value: 2 value: 3 value: 5 value: SENTINEL next: > next: > next: > next: > (c) Write pseudocode to add an element onto the end of a linked list. 1 def append ( value, l i n k e d l i s t ) : 2 newend = new node 3 newend. value = value 4 newend. next = None # ( or SENTINEL) 5 curend = end node o f l i n k e d l i s t 6 curend. next = newend (d) Looking at the list from (b), you notice that we forgot to add in a 4. What is a procedure for doing this? (There are many possibilities.) Use some variation of this strategy: Find the preceding element s node (in this case, 3), link its next node to the new node containing 4, then link that new node to what was the following node. 1

2 Stacks and Queues 2. If we wanted to implement a stack as a linked list, what linked-list operations would correspond to push() and pop()? push( stack, element ) insertfront( linked-list, element ) pop( stack ) removefront( linked-list ) 3. It is possible to implement both stacks and queues using only simple Python lists. (a) Write the following functions that implement stack functionality atop a Python list. Your stack must provide the following functionality: push(lst, elm) Push elm onto the top of the stack pop(lst) Return the top element of the stack and remove it from the stack isempty(lst) Return whether the stack is empty peek(lst) Return the top element of the stack without modifying the stack 1 def push ( l s t, val ) : 2 l s t. append ( val ) 3 def pop ( l s t ) : 4 return l s t. pop ( ) 5 def peek ( l s t ) : 6 return l s t [ 1] 7 def isempty ( l s t ) : 8 return ( l e n ( l s t ) == 0) (b) Write the following methods to create a queue in similar fashion to previous question (with a Python list as the data structure managing elements under the hood ): enqueue(lst, val) dequeue(lst) 1 def enqueue ( l s t, val ) : 2 l s t. append ( val ) 3 def dequeue ( l s t ) : 4 l s t. pop ( 0 ) (c) Which of the data structures you implemented is more efficient and why? Give a better way to implement the slower structure, and discuss how this would change the time complexity of its operations. Because the queue must be able to modify both ends of the list, it pays an O(n) cost to remove the beginning element during each dequeue operation. This could be reduced to O(1) by using a linked list instead of a Python list. 2

3 Hashing and Hash Tables 4. Chris made a mistake in his hash table implementation! 1 class WonkyHashTable ( ) : 2 def i n i t ( s e l f, s i z e =4): 3 s e l f. t a b l e = [ [ ] for i in range ( s i z e ) ] 4 5 def add element ( s e l f, element ) : 6 s e l f. t a b l e [ s e l f. bad hash ( element ) ] = element 7 8 def c o n t a i n s ( s e l f, element ) : 9 for t in s e l f. t a b l e : 10 i f element in t : 11 return True 12 return F a l s e def bad hash ( s e l f, element ) : 15 return l e n ( element ) % l e n ( s e l f. t a b l e ) def s t r ( s e l f ) : 18 s t = 19 for t in s e l f. t a b l e : 20 s t += s t r ( t ) + \n 21 return s t h t a b l e = WonkyHashTable ( ) 24 for elm in I w r e s t l e d a bear once. s p l i t ( ) : 25 h t a b l e. add element ( elm ) (a) Show what the hash table looks like after the for loop on line 24 completes. [ once, a, [ ], [ ] ] (b) What is wrong with the code? What can we do to make the function behave as Chris expects it to behave? The issue is on line 6. Whenever bad hash() dictates that an element should be placed in an occupied bucket, that bucket s contents get overwritten! Change s e l f. t a b l e [ s e l f. bad hash ( element ) ] = element to s e l f. t a b l e [ s e l f. bad hash ( element ) ]. append ( element ) (c) Draw the table of the properly behaving hash function. [ [ w r e s t l e d, bear, once ], [ I, a ], [ ], [ ] ] (d) Assuming that this hash table will only be used on strings, is the hashing function being used a good one? Why or why not? No: It ignores the fact that most English words are the roughly the same length. The number of collisions is expected to be massive. We should take advantage of the characters in the input strings, not the number of characters. 3

4 Classes 5. Write one or more classes and maker function(s) to describe the following: A Hotel hotel name (a string) hotel location (a string) the hotel s Rooms (a list). A Room room price per night (a number) room capacity (a number) room number/label (a number). 1 #!/ usr / bin / python 2 from r i t o b j e c t import 3 4 class Hotel ( r i t o b j e c t ) : 5 s l o t s =( name, rooms, l o c a t i o n ) 6 7 def mkhotel (name, rooms, l o c a t i o n ) : 8 h o t e l = Hotel ( ) 9 h o t e l. name = name 10 h o t e l. rooms = rooms # a l i s t c o n t a i n i n g Room o b j e c t s 11 h o t e l. l o c a t i o n = l o c a t i o n 12 return h o t e l class Room( r i t o b j e c t ) : 15 s l o t s =( number, c a p a c i t y, p r i c e ) def mkroom( number, capacity, p r i c e ) : 18 room = Room( ) 19 room. number = number 20 room. c a p a c i t y = c a p a c i t y 21 room. p r i c e = p r i c e 22 return room 4

5 Sorting 6. Fill in the table for the asymptotic running time of each sorting algorithm. Best Worst Average Merge sort O(n log(n)) O(n log(n)) O(n log(n)) Quicksort O(n log(n)) O(n 2 ) O(n log(n)) Heap sort O(n log(n)) O(n log(n)) O(n log(n)) 7. What sorting algorithm splits its input list into two other lists, one which has all elements that are smaller than a value (which is randomly selected) and one which has elements that are larger than the randomly selected value? Quicksort. 8. In what scenario does Quicksort experience its worst-case time complexity? You may assume that we always pick the first element as the pivot. Data that is (nearly) sorted or is (nearly) sorted in reverse order. 9. What causes Quicksort to run so slowly on the input you describe in the last question? Quicksort splits its input into two lists based on the value of the pivot. If the pivot is either the smallest or the largest element, then one list will only have no elements, while the others will have all of the elements except the pivot. 10. In Quicksort, why should we select a random pivot value, rather than always pivoting on, for example, the first or last element? With real-world data, we re more likely to encounter ordered or semi-ordered data than randomized data. This makes it more likely for us run into Quicksort s worst-case time complexity. We run into this bad time complexity if we select pivots which are near the lowest or highest values. Selecting a random value to pivot on helps us encounter the average case evens out the distribution of ordered and unordered data. Even if we re getting in sorted data, if we select pivots randomly, we should be able to end up with average time complexity. 5

6 11. Show the stages of a merge sort and a quicksort on the following list: [3,5,1,3,2,7,9]. Be sure to identify your pivot. Merge sort: Quicksort (using the first element in the list as a pivot): , , , , ,

7 Heaps and Heapsort 12. For a binary heap containing n elements, what is the maximum number of swaps occurring after an insert operation? log 2 (n + 1), rounded down. 13. Given a node in an array-based binary heap at index i, where are the indices of both its children? What is the index of its parent? The children are at 2i + 1 and 2i + 2. The parent is at i 1. Note that in 2 a 1 indexed 14. Run a heap sort on the following list: [3,5,1,3,2,7,9], showing the heap at each stage. Be sure array system, to heapify the list first. the children Heapify: [3, 5, 1, 3, 2, 7, 9] [3, 5, 1, 3, 2, 7, 9] [1, 5, 3, 3, 2, 7, 9] [1, 3, 3, 5, 2, 7, 9] [1, 2, 3, 5, 3, 7, 9] [1, 2, 3, 5, 3, 7, 9] [1, 2, 3, 5, 3, 7, 9] Sort: [2, 3, 3, 5, 9, 7, 1] [3, 3, 7, 5, 9, 2, 1] [3, 5, 7, 9, 3, 2, 1] [5, 9, 7, 3, 3, 2, 1] [7, 9, 5, 3, 3, 2, 1] [9, 7, 5, 3, 3, 2, 1] [9, 7, 5, 3, 3, 2, 1] would be at 2i and 2i + 1. The parent would be at i 2. 7

8 Greedy Algorithms 15. Given that an algorithm is greedy, is it guaranteed to return an optimal solution? NO. Greedy algorithms always choose the current best solution, which is not necessarily the overall best solution! 16. In the game Black and White 1, the player is faced with a row of identical double-sided chips. You can probably guess what colors the two sides of each chip are. The objective is to flip as many chips as necessary so their exposed colors match that of a target pattern. The catch? Reordering the chips is said to be Impossible by those who seem to know what they re talking about. The real catch? Flipping a group of consecutive tiles can be accomplished in a single action. If every flip takes one action, write a function bwmoves that, given a starting pattern and target pattern as equal-length strings, returns the minimum number of actions required to get them to match. For instance, bwmoves( BBWBBWBBBB, WWWWWBBWWB ) should return 3. 1 def bwmoves( s t a r t, t a r g e t ) : 2 a c t i o n s=0 3 f i r s t =0 4 for index in range ( l e n ( s t a r t ) ) : 5 i f s t a r t [ index]== t a r g e t [ index ] : 6 i f f i r s t!= index : # Each f l i p works up to ( but not i n c l u d i n g ) 7 a c t i o n s+=1 # the index p o i n t e r. I f f i r s t==index, t h a t s 8 f i r s t=index+1 # 0 elements, so t h e r e i s nothing to f l i p. 9 # ( i. e. There were two no f l i p s in a row. ) 10 i f s t a r t [ 1]!= t a r g e t [ 1]: 11 a c t i o n s+=1 12 return a c t i o n s 1 Special thanks to Professor Butler for unwittingly allowing us to rip off his problem. 8