Logic, Algorithms and Data Structures ADT:s & Hash tables. By: Jonas Öberg, Lars Pareto

Transcription

1 Logic, Algorithms and Data Structures ADT:s & Hash tables M7 By: Jonas Öberg, Lars Pareto

2

3

4 Others Queues Priority queues Trees Arrays..

5 Lots of lists Some example properties of a list: access(l, n) : n size(l) : int create() : L append(l, n) : L

6 Abstract Data Type The ADT defines what properties and behaviour a certain class of data has Regardless of the underlying implementation, if the ADT is a List, you can always perform the operations of a List

7 ADT definitions List: nil: () L cons: E x L L first: L E rest: L L Assuming that: first(cons(e, l)) = e rest(cons(e, l)) = l

8 ADT of a Stack Nil: () S push: E x S S top: S E remove: S S isempty: S Boolean top(nil()) = ERROR top(push(i, s)) = i remove(push(i, s)) = s...

9 Changing complexity Linked list Binary tree Min heap Fibonacci heap Hash insert O(1) O(log n) O(log n) O(1) O(1) delete O(n) O(n) O(log n) O(log n) O(1) lookup O(n) O(n) O(log n) O(n) O(1) lookup min O(n) O(1) O(1) O(1) O(n)

10 Hashing as a spell Database > Spells > Hashing Hashing Rank 24 Reduces time for table lookup from linear to constant time.

11 Hash tables in use See Sergey Brin and Lawrence Page: The Anatomy of a largescale Hypertextual Web Search Engine

12 Phone book lookup Should we use a Linked List? key = Bates phone = 5444 next Lookup time: O(n) key = Bates phone = 3072 next

13 Phone book lookup Should we use arrays of arrays? a 1 b 2 a 1 a 1 b b 2 z z 26 t 20 z 26 key = Bates phone = 5444 next

14 Phone book lookup Should we use a Search Tree? key = Mildred phone = 7651 left = right= key = Henry phone = 4664 left = right=... key = Silberman phone = 4664 left = right=... Lookup time: O(log n)

15 Yet another idea What if we could.. 1. Translate each key into a number? 2. Use that number as an array index? bates key = bates phone = 5444 batson Lookup time: O(1) key = batson phone = 3072

16 Coding functions How do we translate strings to integers codes? Idea: add each character code (where a has code 1) and take the sum. a b c d e f g h i j k l m n o p q r s t u v w x y z f ( bates ) = = 47 f ( batson ) =? = = 71 f ( tabes ) = = 47

17 Coding functions How do we translate strings to integers codes? Idea: multiply each character code with 2^n and take the sum. First position: 20 Second position: 21 Third position: 22 a b c d e f g h i j k l m n o p q r s t u v w x y z f ( bates ) = 2*20 + 1* *22 + 5* *24 = 430 f ( tabes ) = 20*20 + 1*21 + 2*22 + 5* *24 = 374 f ( batson ) = 2*20 + 1* * * * *25 = 924 f ( paraskevopoulos ) = 16*20 + 1* *214 = =...

18 Compression functions What if we can find a way to compress large arrays to fit into smaller arrays? tabes bates batson paraskevopoulos batson paraskevopoulos tabes bates

19 Compression functions mod 8 =6 =7 =4 =5 a modulo n - the remainder of a divided by n 9 mod 3 10 mod 3 11 mod 3 12 mod 3 =0 =1 =2 =0 (because 9 = 3*3) (because 10 = 3*3 + 1) (because 11 = 3*3 + 2) (because 12 = 4*3)

20 Compression functions In Java: 374 % 8 = % 8 = % 8 = % 8 = 5 A big interval can be chopped up (hashed) using a compression function like %: [0, 1, 2, 3, 4,..., 13984] % 8 => [0, 1, 2, 3, 4, 5, 6, 7]

21 Compression functions substr(1, 1) =3 =4 =6 Compression functions can take whatever form, although modulus (%) is the most common and easiest for integer values.

22 A hash function is what we get by composing a coding function and a compression function h(x) = c(f(x)) h x f c

23 Collision handling batson paraskevopoulos tabes bates nisse This is called linear probing! Belongs to a category of strategies called Open Addressing (or Closed Hashing ) f( nisse ) = 548 c(f( nisse ) = 548 % 8 = 4

24 Collision handling (linked lists) batson paraskevopoulos tabes bates f( nisse ) = 548 c(f( nisse ) = 548 % 8 = 4 nisse

25 Collision handling Chaining Using linked lists etc to store values outside of the hash when they collide Open addressing Sometimes called closed hashing All values are stored in the hash, collisions are resolved by probing There are a number of different versions of open addressing: Linear probing, quadratic probing, double hashing

26 Load factor The load factor ( ) of a hash table is defined as no of elements no of slots = High - behaviour more like a linked list and less like a hash Low - wastes memory

27 Load factor (high) = 16/ 5 = 3.2

28 Load factor (low) = 2/10 = 0.2

29 Load factor Experiments suggest that we should choose the size of the hash large enough to maintain < 0.9 < 0.5 when lists are used for collision resolution when linear probing is used.

30 Rehashing Fresh map =0 After 2 insertions = 0.2 After 8 insertions = 0.8

31 Rehashing After 8 insertions = 0.8 After 9 insertions = 0.9 After 9 insertions = 0.45

32 Amortized cost Usually an operation is cheap most of the time but on occasion a penalty is taken (rearranging the structure, etc) Rehashing is such a penalty!

33

34 Hash functions in Java public HashMap( int initialcapacity, float loadfactorbound) Initial slot count If exceeds then new slotcount = 2*old slotcount +1 + re-hashing public HashMap() { this(16, 0.75) }

35 Using HashMap HashMap hashmap = new HashMap(100, 0.75); hashmap.put("james", new Integer(1643)); hashmap.put("john", new Integer(8754)); hashmap.put("jeeves", new Integer(9813)); hashmap.put(key, value); Integer j = (Integer) hashmap.get("james"); value = hashmap.get(key) hashmap.size() hashmap.containsvalue(value); hashmap.containskey(key) hashmap.remove(key) // Very slow! // Very fast! Key => value James => 1643 John => 8754 Jeeves => 9813

36

37 Password hashes Login: ab Password: bates ( bates ).hashcode() => Login Password Login Hashcode ab bates ab cb lomjd83 cb db urt624b db eb khs7635 eb

38

39 Encryption versus Digests Here's how encryption works: Login PIN-Code Login Encrypted ab 6534 ab 4356 cb 9812 cb 2189 db 7136 db 6317 eb 6494 eb 4946 Using the same encryption key, we can encrypt and decrypt (two-way operation)

40 Encryption versus Digests Login Password Login Hashcode ab bates ab cb lomjd83 cb db urt624b db eb khs7635 eb Not encrypted! Hashes are Digests (one-way function)

41

42 How likely is a collision? MD5 is 128 bits: 340,282,366,920,938,463,463,374,607,431,768,21 1,456 possible hashes SHA1 is 160 bits Four billion times larger than MD5

43 Manufacturing collisions In 1996, MD5 was broken Hans Dobbertin was able to show two messages with the same digest (a collision) In 2006, an algorithm was shown which can find a collision in just a few minutes In december 2008, researchers showed that fake SSL certificates can be created if MD5 is used Don't use MD5 if collisions matter!

44 This weeks problem Look at in Goodrich & Tamassia Example implementation of a hash data structure, using linear probing Change the open addressing scheme to double hashing, instead of linear probing Compare double hashing and linear probing and write a report based on this