if (Q.head = Q.tail + 1) or (Q.head = 1 and Q.tail = Q.length) then throw F ullqueueexception if (Q.head = Q.tail) then throw EmptyQueueException

Transcription

1 data structures en algorithms exercise class 7: some answers Goal Understanding of the linear data structures stacks, queues, linked lists. Understanding of linked representations of (mainly binary) trees, and tree traversals. Material Book 10.1, 10.2, 10.4 and the slides of lecture 7. Exercises 1. Adapt the procedures enqueue and dequeue from the book such that they also deal with overflow and underflow. (Indication.) For enqueue, add if (Q.head = Q.tail + 1) or (Q.head = 1 and Q.tail = Q.length) then throw F ullqueueexception For dequeue, add if (Q.head = Q.tail) then throw EmptyQueueException 2. Provide pseudo-code descriptions for the operations size(q), isempty(q), and head(q) of the abstract data type for queues. We assume n = Q.length to be the size of the array. 1

2 Algorithm size(q): if Q.head = Q.tail then return 0 if Q.head < Q.tail then return Q.tail Q.head if Q.tail < Q.head then return n Q.head + Q.tail Algorithm isempty(q): return Q.head = Q.tail Algorithm head(q): return Q[Q.head] 3. Assume given two stacks, both with operations push and pop in O(1). Give in this setting an efficient implementation of a queue with operations enqueue and dequeue. Analyze the running time of the queue operations in terms of O. We assume two stacks S 1 and S 2 with operations push and pop in O(1). We implement the operation enqueue of a queue Q as follows: Algorithm enqueue(q, e): push(s 1, e) This operation is in O(1). Idea for dequeue: If S 2 non-empty, then pop from S 2. If S 2 empty, then pop every element from S 1 and push on S 2 ; next pop from S 2. The following is pseudo-code for dequeue of a queue Q: Algorithm dequeue(q): if isempty(s 2) then while not isempty(s 1) do push(s 2, pop(s 1)) return pop(s 2) 2

3 This operation is in O(1) on average. Every element which is added and removed enters and leaves (once) S 1, and enters and leaves (once) S Assume given two queues, both with operations enqueue and dequeue in O(1). Give in this setting an implementation of a stack with operations push and pop. Analyze the running time of the stack operations in terms of O. We assume two queues Q 1 and Q 2 with operations enqueue and dequeue in O(1). We implement the operation push as follows: Algorithm push(s, e): enqueue(q 1, e) This operation is in O(1). Idea for pop: If Q 1 non-empty, then dequeue every non-head element of Q 1, and enqueue them on Q 2 ; next dequeue from Q 1. If Q 1 empty, then dequeue every non-head element from Q 2, and enqueue them on Q 1 ; next dequeue Q 2. Pseudo-code for pop: Algorithm pop(s): x := dequeue(q 1) while not isempty(q 1) do enqueue(q 2, x) x := dequeue(q 1) while not isempty(q 2) do enqueue(q 1, dequeue(q 2)) return x This operation is in O(n). 5. Provide pseudo-code descriptions for the operation insertfirst on singly linked lists, and on doubly linked lists. The operation insertfirst gets as input a list and a key, and adds a node with the input-key at the beginning of the input-list. Give the worst-case time complexity of your operations in terms of O. 3

4 We consider the implementation of singly linked lists. Algorithm insertfirst(l, k): new Node x x.key := k x.next := L.head L.head := x The worst-case time complexity of this method is in O(1), because we perform in every line an operation in constant time. The (worst-case) time complexity does not depend on the size of the input. Now for doubly-linked lists: Algorithm insertfirst(l, k, ): new Node x x.key := k x.next := L.head if L.head nil then L.head.prev := x L.head := x x.prev := nil This algorithm is in O(1). 6. In the setting of doubly linked lists, give pseudo-code for the operation insertafter that takes as input a list, a first key, and a second key. If a node n with the first key is present in the list, then it inserts a new node with the second key directly after node n. What is reasonable to specify what should be done in case the first key is not present in the input-list? Analyze your operation in terms of O. 4

5 Algorithm insertafter(l, k, l): x := L.head while x nil and x.key k do x := x.next if x nil then new Node u u.key := l u.next := x.next u.prev := x x.next.prev := u x.next := u Here we do not change the input-list L in case the key k is not present in L. Another option is to insert in that case a node with key l as first node in the list. The worst-case running time of the procedure is in O(n). 7. Give a non-recursive procedure in O(n) that reverses a singly linked list of n elements. The procedure should use no more than constant storage space beyond the space needed for the list itself. (Is your procedure also in Θ(n)?) 5

6 Algorithm reverse(l): first := L.first if first = null or first.next = nil then else return L second := first.next third := second.next second.next := first first.next := nil L.last := first current := third previous := second while not current = nil do next := current.next current.next := previous previous := current current := next L.first := previous As for all other answers: there are often several correct approaches. 8. Give an implementation of a stack using a singly linked list. What is the top of the stack? Provide operations for push and pop in O(1). We implement a stack S using a singly linked list L. The top of the stack is the first node in the list. The method for push: Algorithm push(s, k): insertfirst(l, k) Because insertfirst for singly linked lists is in O(1), this implementation of push is also in O(1). The method pop (we should add an exception for the case we pop from an empty stack): Algorithm pop(s): o := L.head.key L.head := L.head.next return o 6

7 If we first have to search for a node in the list in order to delete that node, the operation for remove is in O(n). However, if we already have the node that is to be removed, the operation for remove is in O(1). The method above is in O(1). 9. Give an implementation of a max-priority queue using a(n unsorted) singly linked list. What is the worst-case time complexity for the operations for adding and deleting? We use a singly linked list L. We assume that we have operations first and last and also insertfirst (in the book: listinsert) on singly linked lists. The idea for adding an element is just adding it at the beginning of the list. This is not expensive. The idea for deleting an element is first traverse the list, and then remove a maximum of the list. This operation is expensive. Pseudo-code for insertion: Algorithm insertpq(k): insertfirst(l, k) The worst-case complexity of this algorithm is the worst-case complexity of insertfirst for singly linked lists which is in O(1). We implement removemax(h), the operation removing (and returning) the maximum key from H as follows. 7

8 Algorithm removemax(h): if H.first = null then return error m := current := H.f irst previous := null while not current = null do if m < current.key then m := current.key maxprevious := previous previous := current current := current.next if maxprevious = null then if H.first = H.last then else H.first := null H.last := null H.f irst := H.f irst.next if maxprevious.next = H.last then H.last := maxprevious maxprevious.next := maxprevious.next.next return m This algorithm is in O(n) because we walk with current and previous together through the list to find the maximum element. 10. (recap) Give an algorithm in O(n log n) that takes as input a sequence A of n integers, and gives back as output a sequence in which every integer from A occurs exactly once. Intuition: first sort the sequence, which can be done in O(n log n), then walk through the sequence to remove duplicates. Pseudo-code for the algorithm: Algorithm removeduplicates(a): A := mergesort(a) n := A.length() 8

9 11. (recap) duplicates := 0 for i := 2 to n: if A[i] = A[i - 1] then duplicates := duplicates + 1 new Array B[n - duplicates] B[1] := A[1] j := 2 for i := 2 to n: if A[i]!= A[i - 1] then B[j] := A[i] j := j + 1 return B The recurrence for merge sort is: { 1 als n = 1 T (n) = 2T ( n 2 ) + n als n > 1 Solve the recurrence for n a power of 2, and argue that the worst-case time complexity of merge sort is hence in O(n log n). We use the substitution method to solve this recurrence. For large n: T (n) = 2T ( n 2 ) + n = 2(2T ( n 4 ) + n 2 ) + n = 4T ( n 4 ) + 2n = 4(2T ( n 8 ) + n 4 ) + 2n = 8T ( n 8 ) + 3n =... = 2 i T ( n 2 i ) + in We arrive at the startvalue for n = 1 if n 2 = 1. Then we havet: n = 2 i en i dus i = log n. Substitute i = log(n). This yields: T (n) = n + n log(n) 9