quiz heapsort intuition overview Is an algorithm with a worst-case time complexity in O(n) data structures and algorithms lecture 3

Transcription

1 quiz data structures and algorithms lecture 3 Is an algorithm with a worst-case time complexity in O(n) always faster than an algorithm with a worst-case time complexity in O(n 2 )? intuition overview inventor: J.W.J. Williams in 1964 we organize the input-array as a max-heap which is a neat binary tree we deal with the height of the tree (log n) instead of with the length of the array (n) we have to start by turning our arbitrary input-array into a max-heap also we have to maintain the property of being a max-heap

2 overview tree: definitions (see book B5) set of nodes with a parent-child relation there is a unique distinguished node root every non-root has a unique ancestor / predecessor / parent a node may have successors / descendants / children a node without successors is a leaf or external a node with successors is internal tree: recall definitions binary tree: definitions the depth of a node is the length of the path to the root the height of a node is the maximal length of a path to a leaf the height of a tree is the height of the root, or the maximal depth a level or layer of a tree consists of all nodes of the same depth the number of levels is the height of the tree plus one binary tree: every node has zero, one, or two (ordered) successors binary tree is complete if: all levels are completely filled binary tree is almost or nearly complete if : all levels are completely filled except possibly the lowest one which is filled left-to-right complete almost complete normal binary an almost complete binary tree corresponds naturally to an array

3 height and number of elements consider an almost complete binary tree of height h if the lowest level contains one element: number of elements is n = h = 2 h = 2 h if the lowest level is full: number of elements is n = h = 2 h+1 1 so 2 h n 2 h h+1 so h log n h + 1 parent-children relation in the array i an index in the array Algorithm parent(i): return i/2 Algorithm left(i): return 2i so h = log n this is important for the complexity of Algorithm right(i): return 2i + 1 heap max-heap: definition data structure used for sorting and for other things (priority queue) intuition: binary tree all levels from as full as possible if we walk downwards then keys decrease condition on the shape: an almost complete binary tree every node is labeled with a key / label from a totally ordered set max-heap property on the keys: on every path from the root to a leaf the labels / keys are non-increasing H[parent(i)] H[i] hence max key at the root imagine a min-heap

4 max-heap: example overview MaxHeapify: bubble in MaxHeapify MaxHeapify(H, i) with i a node in H left and right of i satisfy the max-heap property we have a node with left and right max- we reconstruct the max-heap property using a down-heap bubble consider i, its left-child l and its right-child r determine max of labels of i, l, r if i has the largest label then done if l largest label: swap labels of i and of l, do MaxHeapify(H, l) if r largest label; swap labels of i and of r, do MaxHeapify(H, r)

5 MaxHeapify: pseudo-code MaxHeapify: time complexity determined by height Algorithm MaxHeapify(A, i): l := left(i) r := right(i) if l A.heap-size and A[l] > A[i] then largest := l else largest := i if r A.heap-size and A[r] > A[largest] then largest := r if largest i then swap(a[i], A[largest]) MaxHeapify(A, largest) intuition: time complexity of down-heap bubble determined by height of the heap so in O(log(n)) (1) with h the height of the heap: T (h) = T (h 1) + 1 if h > 0 gives T (h) O(h) then use h Θ(log n) gives T (n) O(log n) (2) with n the number of nodes of the heap: T (n) = T ( 2 3n) + 1 if n > 1 gives T (n) O(log n) because in the worst case the bottom level is exactly half full MaxHeapify: intuition of correctness overview induction on the height of node i if the height is 0, then immediate if the height is > 0, then two cases case largest = i: immediate case largest = l (and equivalently for largest = r): use induction

6 bottom-up heap construction: idea building a heap: example consider array as proto-heap assume that for index i both immediate subtrees, at index 2i and at index 2i + 1, are already build a heap from the following input consisting of = 15 numbers: use MaxHeapify at index i building a heap: pseudo-code buildmaxheap: correctness use the following loop invariant: at the start of the for-loop each node i + 1,..., n is the root of a max-heap Algorithm buildmaxheap(h): H.heap-size := H.length for i = H.length/2 downto 1 do MaxHeapify(H, i) init: for i = n 2 the nodes i + 1,..., n are leaves hence max- loop: children are max- by induction use correctness of MaxHeapify end: for i = 0 the invariant gives correctness of the output

7 buildmaxheap: complexity alternative algorithms for? rough estimation: for each of the n 2 internal nodes of the heap we do MaxHeapify which is in O(h) which is O(log n) so buildmaxheap in O(n log n) increasing from 1 to n 2? try [3, 2, 1, 4] with i = 1, 2, 3 more precise estimation: for every height j in 0,..., log n for each of the at most n 2 j+1 nodes of height j we do MaxHeapify which is in O(j) j= log n we calculate Σj=0 n O(j) 2 j+1 so (! read in the book) buildmaxheap is in O(n) insert n keys one by one start with A.heap size = 0 and A.length = n this will be in O(n log n) (not yet discussed) overview : idea first part: turn the input-array into a max-heap second part: swap the key on the root with the key on the last node exclude the last node from the heap, so decrease the heap size reconstruct the heap

8 : pseudo-code example H[1... n] an array of integers directly after building the heap: H.heap-size = H.length we start already with a max-heap so we omit the first part Algorithm (H): buildmaxheap(h) for i = H.length downto 2 do swap H[1] and H[i] H.heap-size := H.heap-size 1 MaxHeapify(H, 1) [6, 5, 4, 1, 2, 3] : properties inspired by : smooth sort why is correct? what is the worst-case running time of? buildmaxheap in O(n) n 1 calls of MaxHeapify with every call in O(log n) hence the worst-case running time of is in O(n log n) why is in-place? what is a best-case input?

9 smooth sort: inventor material Edsger W. Dijkstra Turing Award 1972 book 6.1, 6.2, 6.3, 6.4