CS 206 Introduction to Computer Science II

Transcription

1 CS 206 Introduction to Computer Science II 04 / 16 / 2018 Instructor: Michael Eckmann

2 Today s Topics Questions? Comments? Graphs Shortest weight path (Dijkstra's algorithm) Besides the final shortest weights let's think about the paths themselves Hash tables Michael Eckmann - Skidmore College - CS Spring 2018

3 Graphs Example on the board and then pseudocode for Dijkstra's algorithm. vi means vertex i, and (j) means weight j v0-> v1(2), v3(1) v1-> v3(3), v4(10) v2-> v0(4), v5(5) v3-> v2(2), v4(2), v5(8), v6(4) v4-> v6(6) v5-> null v6-> v5(1) Dijkstra's algorithm, given a starting vertex will find the minimum weight paths from that starting vertex to all other vertices.

4 We can reuse the code we wrote to set vertices as visited or unvisited. We can reuse our code to handle a directed graph, but we must add the ability for it to be a weighted graph. We need a minimum Priority Queue, that is, one that returns the item with the lowest priority at any given dequeue(). We need a way to store all the path lengths. Also, we need to initially set all the minimum path lengths to Integer.MAX_VALUE (this is the initial value we want to use for the path lengths, because if we ever calculate a lesser weight path, then we store this lesser weight path.)

5 Dijkstra's algorithm pseudocode (given a startv) set all vertices to unvisited and all to have pathlen MAX set pathlen from startv to startv to be 0 add (item=startv, priority=0) to PQ while (PQ!empty) { v = remove the lowest priority vertex from PQ (do this until we get an unvisited vertex out) set v to visited for all unvisited adjacent vertices (adjv) to v { if (current pathlen from startv to adjv) > (pathlen from startv to v + weight of the edge from v to adjv) then { set adjv's pathlen from startv to adjv to be weight of the edge from v to adjv + pathlen from startv to v add (item=adjv, priority=pathlen just calculated) to PQ } // end if } // end for } // end while

6 What if we wanted to not only display the minimum weight path to each vertex, but also the actual path (with the intervening vertices)?

7 Hashing is used to allow very efficient insertion, removal, and retrieval of items. Hashes Consider retrieval (searching) with several structures To find data in an unordered linear list structure O(n) To find data in an ordered linear array O(log n) To find data in a balanced BST O(log n) What orders are better than log n?

8 Hashing is used to allow Hashes inserting an item removing an item searching for an item all in constant time (in the average case). Hashing does not provide efficient sorting nor efficient finding of the minimum or maximum item etc.

9 Hashes We want to insert our items (of any type (String, int, double, etc.)) into a structure that allows fast retrieval. Terms: Hash Table (an array of references to objects(items)) table_size is the number of places to store Hash Function (calculates a hash value (an integer) based on some key data about the item we are adding to the hash table.) Hash Value (the value returned by the hash function) the hash value must be an integer value within [0, table_size 1] this gives us the index in the hash table, where we wish to store the item.

10 Just to give an idea of how to insert and retrieve items into a hash table (this does not use a good hash function) Consider our items are simply ints Consider our Hash Function to be f(x) = x % n (this is not a typical hash function) The hash function returns a hash value which is modded by the size of our hash table array to compute the index where we wish to store our item. example on the board (assume n=8, add items 24, 3, 17, 31) Then we can reverse the process to see if a particular item is in our hash table. Hashes

11 In our example (assume n=8, add items 24, 3, 17, 31), what if we needed to insert item 11 into our hash? There'd be a collision. Hashes There are several strategies to handle collisions Assume the hash value computed was H the chosen strategy effects how retrieval is handled too Open Addressing (aka Probing hash table) Place item in next open slot (linear probing) H+1, or H+2 or H+3... Place item in next open slot (quadratic probing) H+1 2, or H+2 2, or H+3 2, or H+4 2,... Wraparound is allowed / required

12 Hashes There are several strategies to handle collisions Another technique besides Open Addressing, is Separate chaining Each array element stores a linked list Examples of these techniques on the board.

13 Hashes Typically we won't know our keys ahead of time (before we create our hash) But if we did know all our keys ahead of time, would that help us in any way?

14 Hashes Let's come up with a hash table to store Strings we'll need to come up with the size of our table we'll need to decide whether we will use separate chaining or open addressing hashing We'll need to create a hash function. (We'll talk about strategies for creating good hash functions next time) We'll also allow insertion and retrieval (determine if an item exists in the hash).

15 Hashes Strategies for best performance want items to be distributed evenly (uniformly) throughout the hash table and we want few (or no) collisions so that depends on our data items, our choice of hash function and our size of the hash table also need to decide whether to use a probing (linear or quadratic) hash table or to use a hash table where collisions are handled by adding the item to a list for the index (hash value) another method is called double hashing. if choices are done well we get the retrieval time to be a constant, but the worst case is O(n) we also need to consider the computations needed to compute the hash value (but this will be a constant amount of work)

16 Clustering Why is it bad? Hashes How to avoid it? Quadratic probing (avoids it to some degree) Double Hashing can avoid it

17 Hashes It is possible, with a poor choice of table size, and quadratic probing, we could end up never finding a spot in the table to place an item. For quadratic probing, if the table size is prime, then a new element can always be inserted if the table is at least half empty.

18 Hashes Double hashing is an open address hashing method, not a separate chaining method. Therefore it does not use an array of lists. It uses just an array of the items to represent the hash table. - Create a hash table as an array of items - Create a hash function hash1 that will return a hash value that we will call hv1 to place the item in the table. - If a collision occurs, call a second hash function hash2 which returns an int that we will call hv2. Use this hv2 as the amount of indices to hop to find another place to put the item.

19 Hashes Example: if an item initially hashes to value hv1=5 and this causes a collision, then using the same item we compute hv2 to be 7 using the second hash function. We would then check if there's an open slot in 5+7=12. If it's open, place the item there. If that's not open, look in 12+7=19, and if that's not open continue checking 7 slots away until we find an open slot. Wrap around when necessary (using mod the size of table). Remember the goals of hashing: - we want the data to be distributed well throughout the hash table - we want few collisions in the average case and the worst case

20 Hashes Another thing that must be taken care of is a situation such as this. Suppose we have a hash table of size 20 and all of the even numbered slots are filled (that is, index 0, 2,... 18) and we are trying to insert an item with hv1 of 4. This is a collision. So if we compute hv2 to be say 6,

21 ( 4+6)%20=10 is filled, Hashes (10+6)%20=16 is filled, (16+6)%20= 2 is filled, ( 2+6)%20= 8 is filled, ( 8+6)%20=14 is filled, (14+6)%20= 0 is filled, ( 0+6)%20= 6 is filled, ( 6+6)%20=12 is filled, (12+6)%20=18 is filled, (18+6)%20= 4 is filled, ( 4+6)%20=10 (we're back where we started...)

22 Hashes and this would go on forever, because we came back to the starting index without examining all the slots. Actually in this case we examined only the filled slots, and ignored all the empty slots!!

23 Hashes To avoid this problem, double hashing requires that the table size must be relatively prime with respect to the value (hv2) returned by hash2. This is important because this will guarantee that if there's an empty slot, we will eventually find it. Numbers that are relatively prime are those which have no common divisors besides 1. You could have a table_size which is an integer p, such that p and p-2 are prime (twin primes). Then the procedure is to compute hv1 to be some int within the range 0 to table_size-1, inclusive. Then compute hv2 to be some int within the range 1 to table_size-3. This will guarantee that if there's an empty slot, we will find it. This method was devised by Donald Knuth.

24 Hashes Strategies for best performance For double hashing & quadratic probing we should have a prime as our table size Additionally for double hashing we need the second hash value to be relatively prime to the table_size. This will prevent the situation described earlier with the table being half full but we never looked at any of the open slots. The hv2 being relatively prime with table_size will guarantee that if there's an open slot, we will find it.