CS 241 Analysis of Algorithms

Transcription

1 CS 241 Analysis of Algorithms Professor Eric Aaron Lecture T Th 9:00am Lecture Meeting Location: OLB 205 Business HW4 out Due Tuesday, Nov. 5 For when should we schedule a make-up lecture? Exam: Tuesday Oct. 29 Review session: Monday, Oct. 28, 4:45pm (I expect it to be in this room, but I haven t finalized that yet) Reading: CLRS, Ch. 6, Ch

2 Yes, It s A Heap A heap is a complete binary tree that is heap-ordered (Remember the definition of complete binary tree?) Heap-ordered: We might equivalently say a tree satisfies the heap property when it is heap-ordered A tree is heap-ordered if for every node, its key (i.e., value) is the key of any descendant Another example heap, stored in an array What are the indices of a parent / left-child / right-child of a node? For node i, index of parent: i/2 left child: 2i right child: 2i+1 Heapify: An Introduction The heapify function restores heap order when something violates it Idea: node keeps getting swapped down in the tree until it s in a place that respects heap order Note: other than that node, tree respects heap order How could a heapify-like function be used to implement various priority queue operations (e.g., insert, increase key, extract max)? 2

3 Heapify Heapify for a max-heap (i.e., maximal element at root) Input: An unordered array A[1 n] of comparable items and the index i of a node whose subtrees are max-heaps, but node i might violate max-heap property. Output: A permutation of A such that i is the root of a max-heap Correctness argument? Complexity? Max-Heapify(A,i) 1. left = 2i; right = 2i + 1 /* indices of left & right children of A[i] */ 2. largest = i 3. if left heapsize(a) and A[left] > A[i] 4. largest = left 5. if right heapsize(a) and A[right] > A[largest] 6. largest = right 7. if largest i 8. swap(a[i], A[largest]) 9. Max-Heapify(A, largest) Build-Heap With Max-Heapify, building a heap is straightforward Input: An unordered array A[1 n] of comparable items Output: A permutation of A such that A is a max-heap Correctness argument? Complexity? Build-Max-Heap(A) 1. for i =A.length downto 1 // Note: diff. from book 2. Max-Heapify(A, i) 3

4 Heapsort Natural application: Heap-based sorting algorithm! Input: An n-element array A[1 n]. Output: An n-element array A in sorted order, smallest to largest. Correctness / complexity arguments? Correctness argument is a HW exercise What s time complexity? HeapSort(A) 1. Build-Heap(A) /* put all elements in heap */ 2. for i = A.length downto 2 3. swap A[1] with A[i] /* puts max in ith array position */ 4. A.heap-size = A.heap-size Max-Heapify(A,1) /* restore heap property */ Heap-Insert Assuming there is enough room in the array to add one more node to the heap Can put the new node in the last position in the heap-array, and then re-heapify from there swap that new node up the tree until heap property is restored Correctness / complexity arguments? Max-Heap-Insert(A, key) 1. heapsize(a) = heapsize(a) i = heapsize(a) 3. while i > 1 and A[parent(i)] < key 4. A[i] = A[parent(i)] 5. i = parent(i) 6. A[i] = key 4

5 Heap Creation: A Complexity Analysis Which method is better for creating a heap? Using Heap-Insert to insert n nodes? Using Build-Max-Heap from an existing array? Each method can be easily seen to be O(n lg n) Is that bound tight for either method? Or is one or the other also O(f(n)) for some f better than n lg n? Hint: One is also O(n). (See CLRS Ch. 6.3) What makes one of these faster than the other? Build-Max-Heap(A) 1. for i =A.length downto 1 2. Max-Heapify(A, i) Do you see how? Max-Heap-Insert(A, key) 1. heapsize(a) = heapsize(a) i = heapsize(a) 3. while i > 1 and A[parent(i)] < key 4. A[i] = A[parent(i)] 5. i = parent(i) 6. A[i] = key A Step Back: Data Structures for Dynamic Sets In general: It s often useful to represent a collection of data that changes over time, to use or manipulate in application-specific ways Some data structures for such dynamic sets and operations they efficiently support Stack: retrieving most recent added element Queue: retrieving least recent added element Heap: retrieving element with highest key value; sorting What other operations might we want data structures to support? 5

6 Searching We ve looked at several algorithms and data structures to support efficient sorting A related, common problem is the searching problem Input: A sequence of n elements (numbers) A = <a 1,, a n > and a value v Output: Index i s.t. v = A[i], or nil if v does not exist in A What are some algorithms to solve the searching problem? Searching We ve looked at several algorithms and data structures to support efficient sorting A related, common problem is the searching problem Input: A sequence of n elements (numbers) A = <a 1,, a n > and a value v Output: Index i s.t. v = A[i], or nil if v does not exist in A What are some algorithms to solve the searching problem? When is linear search preferable to binary search, or vice versa? 6

7 Operations on Dynamic Sets Operations the dynamic set data structures might support SEARCH(S, k) returns pointer to element x with key[x] = k (or nil) INSERT(S, x) adds element pointed to by x to S DELETE(S, x) removes element pointed to by x from S MINIMUM(S) returns element with smallest key MAXIMUM(S) returns element with largest key SUCCESSOR(S, x) returns element with next key > key[x] PREDECESSOR(S, x) returns element with next key < key[x] For dynamic set operations, runtime is usually considered in terms of the size of the set (i.e., number of elements currently in the set) Binary Search Trees (BSTs) The binary search tree (BST) data structure supports all of those operations on Dynamic Sets BST: Binary tree that has certain properties about ordering of its contents Illustration of BST Property: Node key is greater than every key value in the left subtree, less than every key value in right subtree Note: Every subtree of a BST is a BST See CLRS Ch. 12 (skip 12.4). Important Note: We re covering BSTs slightly differently from CLRS for example, the text allows for BSTs to contain multiples of a value; we presume all nodes contain distinct elements (the BST represents a set). 7

8 Binary Search Trees (BSTs) The binary search tree (BST) data structure supports all of those operations on Dynamic Sets BST: Binary tree that has certain properties about ordering of its contents Illustration of BST Property: Node key is greater than every key value in the left subtree, less than every key value in right subtree Note: Every subtree of a BST is a BST In-order traversal visits keys in order What s the algorithm for that? [e.g.: Input: r the root of BST B. Output: prints elements of B in order.] 8