Discussion 2C Notes (Week 9, March 4) TA: Brian Choi Section Webpage:

Transcription

1 Discussion 2C Notes (Week 9, March 4) TA: Brian Choi Section Webpage: Heaps A heap is a tree with special properties. In this class we will only consider a binary heap, whose underlying structure is a binary tree. It is a complete binary tree with the following property: Every node holds a value greater than or equal to its children. This means that the root of a heap will have the greatest value in the heap, and that every subtree is a heap. Such heap is called a maxheap. There is also another type called minheap, which you can define by replacing greater than in the sentence above with less than. From now on, let us focus on maxheaps, as a maxheap and a minheap do not differ in anything else. As one can see, values in a heap are not necessarily sorted. A heap is more useful in situations where what matters is the maximum value, because you don t need to track down the tree for the largest value; the root has it. (How long does it take to find the maximum value in a heap, in Big-O?) This is a big advantage if there are a lot of values stored in the heap. At the same time, the same property of a heap makes it unsuitable for general search operations. So here is the set of operations we need to define for heaps: insertion - insert a new node into the heap findmax - find the maximum value deletemax - delete the node with the maximum value Before discussing the algorithms, let us talk about how a heap is implemented. Unlike what we did for binary trees, we ll use an array to implement our heap. Array Implementation of a heap $" %" &" '" &" '" %" $" The figure on left shows a valid heap. It is a complete binary tree, and every parent is greater than its children. Because it is a complete tree, we can index each node from top to bottom, left to right, sequentially. The root is indexed 0, and its children are indexed 1 and 2, and so forth. Because we can come up with such a numbering system, we can simple create an array, say heap, where each node i is stored in heap[i], as follows: findmax It probably is a waste of time to talk about how to implement this, no? Question: What is the running time of this operation? Copyright 2011 Brian Choi Week 9, Page 1/6

2 insertnode(node newnode) Phase 1 How do we add a new node? First thing to worry about is that our tree must be complete. In the graph we saw in the previous page, after the insertion of the new node, there must be another node in the right branch of 6. So we will add a new node at the end of this tree, to make it a right structure. Question: What happens to the array at this moment? Phase 2 Let s add a node with value 8. Every node except 8 is in the right place. The problem now is to find the right position for 8. Here are some questions to think about: $" $" If the new node is the root, then it s the only node in the tree, so we re done. %" &" '" &" '" %" (" (" If the new node is the left child of its parent, - What should we do if the new node is greater than its parent? - What should we do if the new node is less than or equal to its parent? If new node is the right child of its parent, - What should we do if the new node is greater than its parent? - What should we do if the new node is less than or equal to its parent? The answer is quite simple. If the new node is greater than its parent, we can simply swap the new node with the parent! Otherwise, we re done. In the above case, we switch the positions of 6 and 8, because 8 > 6, after which we will have a valid heap. We might need more swaps though. For example, if the new node had a value of 10 instead of 8, we have to perform another swap, such that 10 becomes the new root of the heap. In summary, we move up the new node until it is at the right position. How do we do this swap in an array? The key is to figure out the index of parent, given the index of the new node. Question: If the new node has an index i > 0, how do you compute the index of its parent? Copyright 2011 Brian Choi Week 9, Page 2/6

3 Here s the algorithm in pseudocode. Suppose the values are integers: insertnode(int newval, int heap[], int size) {! heap[size] = newval; // assume enough space! pos = size;! parent =!!!!! while (parent >= 0 and heap[pos] > heap[parent])! {!!! swap(heap[pos], heap[parent]);!! pos = parent;!! parent =!!!!! }! size++; } Question: What is the running time of this algorithm? deletemax We now talk about deleting the maximum value from the heap. $" %" &" %" &" $" This is what the heap looks like after removing the maximum value. As done in the insertion case, the first thing we do is to correct the structure, so that it becomes a complete graph. To do so, only thing we need to do is to take the last element (2 in this example) and make it become the root. But now this breaks the rule: a parent must be greater than all its children! Therefore, the next step is to find the right position for 2 via successive swapping of nodes. Again, the key question is then to figure out the indices for the left child and the right child. $" $" Question: Given the node i, what are the indices of its children? Left Child: Right Child: %" &" %" &" Here is the pseudocode: Copyright 2011 Brian Choi Week 9, Page 3/6

4 deletemax(int heap[], int size) {! heap[0] = heap[size-1];! size--;! pos = 0;! left_child = 1;! while (left_child < size)!! // if not a leaf! {!!! right_child = left_child + 1;!! // if right child exists!! if (right_child < size &&!!! heap[right_child] > heap[left_child])!!!! {!!! swap(heap[right_child], heap[pos]);!!! pos = right_child;!! }!! // if only left child exists!! else if (heap[left_child] > heap[pos])!! {!!! swap(heap[left_child], heap[pos]);!!! pos = left_child;!! }!! else!!! break;!! left_child =!!!!! } } Question: Why does it matter which path we take (left child vs. right child)? Question: What is the running time, in Big-O? Heapsort Heapsort is a sorting algorithm that uses a heap. Here is the algorithm: Insert all values into a heap, one by one. while (heap is not empty) {! extract the maximum value! delete the maximum value } This should be quite straightforward. Question: What is the running time? Question: Can you use a maxheap to implement in-place heapsort (i.e. without defining an auxiliary structure), which sorts elements in an array in the increasing order? Copyright 2011 Brian Choi Week 9, Page 4/6

5 Hash Tables Before we talk about hash tables, we should understand what this hashing means and why it is useful. Suppose the following scenario: Scenario 1: You walk into the building, and look for someone named David Smallberg. You believe he is somewhere in the building, but don t know where exactly in the building he is. What should you do? You walk to the front desk, and ask the receptionist where he is! He/she will tell you David is in room Now you know where exactly you should go to find him. Scenario 2: You are hired by the company called Boelter Software, and it is your first day at work. You were only told to come to their headquarters, but you don t know which room you are supposed to work in. What should you do? You walk to the front desk, and ask the receptionist where you should go! He/she will tell you You re assigned to room Now you know where exactly you should go and unpack your stuff. This receptionist is your hash function. Given some value, the hash function will tell you where exactly the value can be found. x hash function H H(x) A hash function is a function because H(x) is defined for all possible values x, and its value is the same for the same input. For two different values x and y, H(x) H(y) doesn t necessarily hold. (It is not necessarily one-to-one.) In some sense, a hash function is like a mapping function -- the mapping is done according to some formula defined by H. So suppose there is a hash function that takes a string as a value (e.g. a name like David Smallberg ), and computes a hash value that is a positive integer (e.g. 4531). We can use as an index to store some information about him. What do I mean by this? Suppose Boelter Software wants to keep the list of employees working in it, in some kind of a database. We can certainly use an array for this, maybe indexed by the employee IDs (because names cannot be used as an index). Now, I want to look up David Smallberg in the database. What can I do? Unless the list is sorted by employees names, you will have to perform a linear search, which is O(n). If the list is sorted by employees names, then we can do binary search, which takes O(log n). If 100 people are simultaneously doing lookups on my database, which stores the information of 100,000 employees, it is going to be very slow. Can we do better? How about I have some hash function as explained above. It takes in David Smallberg as an input, and will compute the number 4531, following certain guidelines that we don t really know of. All we know is that when the input is David Smallberg, the result will be 4531, and that it can be computed very efficiently (O (1)). So something we can do is to store David s information in the 4531st slot in the array. So when I search for David Smallberg, what my database will do is to compute the hash value, which is going to be 4531, and look into the 4531st slot of the array to fetch this information. Copyright 2011 Brian Choi Week 9, Page 5/6

6 This will work, as long as no other name maps to But what if Carey Nachenberg also maps to 4531? When storing Carey Nachenberg after David Smallberg, it will overwrite David s information, which is not desirable. #$%&'(#)*%+,%$-.' 6789' :' 678;'!/#012'34#55,%$-.' 6789' 6789' 678<' :' "' / =' So what we do is to make David and Carey share the room. We can do this by registering both of them in That is, the 4531st slot in the array will have to hold both values, and this is sometimes unavoidable. (If the array has 10,000 slots, and we have more than 10,000 names to store, then there should be at least one slot with two names (by what s called Pigeonhole Principle)). Now, depending on how good our hash function is, of 10,000 rooms, some rooms will be filled in, some rooms will be vacant, and some rooms will have more occupants than others. This means each slot should point to some variable-length data structure. What variable-length data structure do we know about? Linked lists and dynamic arrays are certainly ones that fall into this category. So this is your hash table! It is essentially an array of lists. Question: What is the running time of insert operation? (assuming the array is large enough) Question: What is the running time of remove operation? (assuming the array is large enough) Question: What is the running time of search operation? (assuming the array is large enough) What happens to the complexity here if the array is not large (i.e. an array of size 10 where there are 10,000 elements to store)? One more note. This is merely the conceptual description of what a hash table is. An important fact to note is that every element has a key (e.g. David Smallberg in the above example), which is an index for the information. You want to retrieve all the information that belongs to the particular key, so each element in the list should be a (key, value) pair. Copyright 2011 Brian Choi Week 9, Page 6/6