1 / 62

Sets & Maps

Sets & Maps. Overview. The Collections Hierarchy Sequence vs. Associative Containers Sets Maps Implementing Sets and Maps Trees Hash tables. the Collection interface. List interface extends Collection interface Collection is an object that holds other objects

jillianb
Download Presentation

Sets & Maps

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Sets & Maps

  2. Overview • The Collections Hierarchy • Sequence vs. Associative Containers • Sets • Maps • Implementing Sets and Maps • Trees • Hash tables

  3. the Collection interface • List interface extends Collection interface • Collection is an object that holds other objects • Collections have base types (<String>, ...) • Sets are another kind of Collection • as are Queues Collection<E> List<E> Set<E> Queue<E> Collection, List, Set & Queue are interfaces; ArrayList & LinkedList are classes ArrayList<E> LinkedList<E>

  4. Collection Methods • Common to Lists, Sets and Queues • add(T), remove(T), clear() • contains, equals, isEmpty, size, toArray • addAll, containsAll, removeAll, retainAll • hashCode, iterator • List and Deque add several methods • different methods for each • Set adds no more methods

  5. the Collections class • The Collections (note the s) class • static methods for Collection objects • like ArrayLists • e.g. Collections.sort(…) • Collection is an interface • set of method headers for a “skill set” • Collections is a class • (static) methods with definitions

  6. Other Collections Methods • Collections.methodName(args..); • frequency(list, 10)  2 [10, 20, 10, 5] • max(list)  20 [10, 20, 10, 5] • min(list)  5 [10, 20, 10, 5] • reverse(list) [5, 10, 20, 10] • replaceAll(list, 10, 7) [5, 7, 20, 7] • swap(list, 0, 2) [20, 7, 5, 7] • shuffle(list) maybe [7, 20, 5, 7] max & min can also take comparators as 2nd argument

  7. Exercise • Write a method that shows how many of each element is in a List<Integer> – but only in the range of the elements in the list • for example: [10, 5, 10, 3, 5, 10, 22, 19, 10, 5] • 3 appears 1 time(s) • 4 appears 0 time(s) • 5 appears 3 time(s) • ... • 22 appears 1 time(s)

  8. Lists vs. Sets • List elements allow duplicates; Sets do not • list1 [a, b, c, a, b, d, a, a, a, a, b, z] • set1 [a, b, c, d, z] • Client puts List elements in order; computer chooses order for Set elements • list1.add("e"); [a, b, c, a, b, d, a, a, a, a, b, z, e] • set1.add("e"); [a, b, c, d, e, z] • Set interface implemented by (e.g.) TreeSet

  9. Container Types • Sequence containers (List) • accessed by position • first element, second, third, …, last • duplicates allowed • Associative containers (Set, Map) • accessed by key (= part of its value) • position is incidental ( doesn’t matter) • no duplicates allowed

  10. 10 20 30 15 7 19 40 21 10 8 42 90 54 0 1 2 3 4 5 6 7 8 9 10 11 12 lion6 31 cat3 99 4 8 elephant6 15 18 55 12 dog7 elf0 11 42 walrus11 Container Types • Sequence (List) • Associative (Set, Map) 25 91 7 3 -5 88 42

  11. Is 4 in the set? yes Is 7 in the set? no How many things are in the set? 10 What is the value of “cat”? 3 Change the value of “elephant” to 7 Is the map empty? no lion6 31 cat3 99 4 8 elephant6 15 18 55 12 dog7 elf0 11 42 walrus11 Associative Containers elephant7

  12. Java Set and Map • Set = collection of unique values • is <key> there or not? • Map = function from key to value • what is the value of <key>? • Set extends Collection; Map does not • Sets can be implemented with Maps • TreeSet implemented using a TreeMap • HashSet implemented using a HashMap

  13. Set and Map Interfaces • Set contains elements of a single type • Set<String>, Set<Integer>, Set<Student> public interface Set<E> extends Collection • Map needs two types: key and value • Map<String, Integer>, Map<String, Student> public class Map<K, V>

  14. Map and Set Application • Simple web page search engine • maintains a Map<String, Set<URL> > • key string = search word (“nonmonotonic”) • Set<URL> = web pages containing that word • Multi-term search uses set intersection • set of pages with “nonmonotonic” = s1 • set of pages with “reasoning” = s2 • s1 intersect s2 = set of pages with both

  15. Set Element Order • Depends on the implementation Set<String> treeSet = new TreeSet<>(); Set<String> hashSet = new HashSet<>(); treeSet.add("words"); hashSet.add("words"); treeSet.add("in"); hashSet.add("in"); treeSet.add("this"); hashSet.add("this"); treeSet.add("set"); hashSet.add("set"); System.out.println(treeSet); System.out.println(hashSet); [in, set, this, words] [set, in, words, this]

  16. 31 99 4 8 15 18 55 12 11 42 Implementing Sets and Maps • Binary Search Trees • linked structure • Hash Tables • array structure 0 1 2 3 4 5 6 7 8 9 10 11 12 / / 15 31 55 4 8 99 31 4 12 55 18 11 18 42 42 15 8 99 / 11 12

  17. Binary Search Trees • Tree: root and children • each child has one parent above it in the tree • Binary Tree: at most two children • a left child and a right child • Binary Search Tree: left < root < right • everything to the left of the root is smaller • everything to the right of root is larger

  18. BST Example • Root is 31 • its children are 8 and 99: 8 < 31 < 99 • Root is 8 • its children are 4 and 12: 4 < 8 < 12 • Everything under 8 is < 31, too • Everything under 99 is > 31, too 31 8 99 55 42 4 12 11 18 15

  19. BST Nodes • BST contains data and two links // for a Set<E> private class BSTNode { E data; BSTNode left; BSTNode right; } // for a Map<K, V> private class BSTNode { K key; V value; BSTNode left; BSTNode right; }

  20. Set and Map Implementations • Root is a BSTNode • also need a comparator • and maybe a count // for Set<E> private BSTNode root; private Comparator<E> comp; private intnumInTree; • root starts as null, numInTree as 0 • comp may be the natural order comparator (o1, o2) -> o1.compareTo(o2)

  21. Finding an Element in a BST • Want to know if 6 is in the tree • How to see? • 6 < 7, so if it’s there, it mustbe in the left sub-tree • 6 > 2, so look right • 6 > 3, look right again • There it is 7 2 12 3 1 6 5 4

  22. Finding an Element in a BST • Want to know if 8 is in the tree • 8 > 7, so look right • 8 < 12, so look left • Nothing there • 8 must not be in the tree 7 2 12 3 1 6 5 4

  23. BST contains Method • Like a binary search for item public boolean contains(E item) { BSTNode cur = root; while (cur != null) { int c = comp.compare(item, cur.data); if (c < 0) { cur = cur.left; } // item < root else if (c > 0) { cur = cur.right; } // item > root else { return true; } // item == root } return false; // item not found }

  24. 9 Inserting Into a BST • Newly inserted node must appearin exactly the right position • If it is bigger than the root: • it must go in the right sub-tree • If smaller, into the left sub-tree • Where in the sub-tree? Recur. • for example, insert 9 7 2 12 1 3 6 5 4

  25. To Insert into a BST • If the root is null • create the new node here • If the item to insert is less than the root • insert into the left sub-tree • If the item to insert is more than the root • insert into the right sub-tree • Otherwise – ignore duplicate item • return false Sets do not allow duplicate elements

  26. BST insert Method • Returns true if inserted, false otherwise • recall: no duplicates allowed public boolean insert(E anItem) { intoldCount = numInTree; root = insertNode(anItem, root); return numInTree > oldCount; } • insertNode creates the new Node (if necessary), places it in the tree, and updates numInTree

  27. BST insert Method • Insert new node, return the root of subtree private BSTNodeinsertNode(E anItem, BSTNode cur) { if (cur == null) { ++numInTree; return new BSTNode(anItem); } int c = comp.compare(anItem, cur.data); if (c < 0) { cur.left = insertNode(anItem, cur.left); } else if (c > 0) { cur.right = insertNode(anItem, cur.right); } return cur; }

  28. Deleting from a BST • Easy if the node is a leaf: • just delete it (for example, 4) 7 2 12 1 3 9 6 5 4

  29. Deleting from a BST • Easy if the node is a leaf: • just delete it 7 2 12 • If it has only one child • we can re-attach the child to the deleted node’s parent (for example, 3) 1 3 9 6 5

  30. Deleting from a BST • Easy if the node is a leaf: • just delete it • If it has only one child • we can re-attach the child to the deleted node’s parent 7 2 12 1 9 6 • But what if it has two children? • delete the 2, for example • now what? 5

  31. 6 6 5 1 1 5 1 1 6 6 5 1 5 5 6 Deleting from a BST • Need to keep the BST property • After 2 is deleted there willjust be the 1, 5 and 6 7 2 12 1 9 6 5

  32. Deleting from a BST • Find the minimum value in theright sub-tree • or the maximum in the left • Copy its value into the root • root was going to be deleted anyway • Delete the node you copied from • it’ll have at most one child 7 5 2 12 1 9 6 5

  33. Exercise • Show the BST that results whenyou delete 5 from this tree • (use “min on right” rule) • Show the BST that resultswhen you delete 7 from this tree • use “min on right” rule 7 5 12 6 1 9 11

  34. BST delete Method • Returns true if deleted, false otherwise public boolean delete(E anItem) { intoldCount = numInTree; root = deleteNode(anItem, root); return numInTree < oldCount; } • Exercise: write deleteNode • hint: it’s very similar to insertNode

  35. Complexity • Average complexity: • on average tree is pretty balanced • contains, insert and delete all O(log N) • Worst case complexity: • insert data in order  one long list • contains, insert and delete all O(N) • There are ways to balance trees • Java uses Red-Black trees

  36. Hash Table Operations • Hash tables are designed to make insertion and finding particular elements fast • both in O(1) average time • deletion also supported in O(1) average time • Other operations expensive or impossible • no way to find the minimum/maximum except by looking at every element • no information on order used at all

  37. Simple-Minded Structure • Simplest way to get O(1) is to have an array with one cell per possible data element • Example: keys drawn from 0..19 • A is an array indexed by 0..19 • A[i] is null if the item with key i is not present • A[i] is the data element if it is present

  38. Simple-Minded Structure • Insertion = create new item & set A[i] • Find = look at A[i] 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 / * / / / / / * / / / / / / * / / * * / 01 Smith Brian 07 Wilson Debra 14 Chan Paulina 17 Lafleur Denis 18 Burns Monty

  39. Large Key Spaces • Key spaces can be very large • key is a 20 character string • coded as ASCII  12820 = 2140 1042 • Impossible to get that much space • Generally only have a few keys • don’t need that much space • few thousands or millions  107

  40. Hash Table Idea • Make the array much smaller • maybe about twice the number of items you’re expecting • Divvy up the keys between the array cells • function from keys to array indices: “hashing” • try to keep them spread out = avoid “collisions”

  41. Hashing • Keys in range 1..100 • take key mod 20 as index into the array 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 / * / / / / / * / / / / / / * / / * * / 41 Smith Brian 94 Chan Paulina 78 Burns Monty 27 Wilson Debra 37 Lafleur Denis 41 mod 20 = 1 94 mod 20 = 14 78 mod 20 = 18 27 mod 20 = 7 37 mod 20 = 17

  42. Note on Hash Table Size • Want HT size to be a prime number • will explain why later • 20 not a good size for a hash table • 19 or 23 would be better • Will use 20 anyway in these notes • easier to do the math! • computer doesn’t have to worry about that….

  43. Note on Hashing Function • Usually broken into two parts • Hash function proper translates key to integer • string  number • number  other number • Result mapped into table using mod (%) • For now just keep it really simple • just using positive integer values and mod

  44. Hashing Exercise • Place the following keys into the hash table • 42, 17, 81, 20, 73 • Hash function = key mod 20 • h(42) = 42 % 20 = 2 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 / / / / / / / / / / / / / / / / / / / /

  45. Collisions • Collision happens when two items hash to same array location 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 / * / / / / / * / / / / / / * / / * * / 41 27 94 37 78 58 Item 58 wants to go in position 18 item 78 already using it “collision”

  46. Collision Frequency • Take a 1000 cell table & good hash function • each cell is equally likely to be hashed to • Chance of collision: • 1st item: 0/1000 • 2nd item: 1/1000 • 3rd item: 2/1000 • … • Nth item: (N–1)/1000

  47. Collision Frequency • What’s the chance of at least one collision? • 1 entry = 1 – (1000/1000) = 0 • 2 entries = 1 – (1000/1000)*(999/1000) = 1/1000 • 3 entries = 1 – (1000/1000)*(999/1000)*(998/1000) 3/1000 • 4 entries  6/1000 • 5 entries (table 0.5% full)  10/1000 = 1% • 100 entries (table 10% full)? about 99.4% (!)

  48. Dealing with Collisions • Two ways of dealing with the problem • Open addressing • put the new item somewhere else • need to figure out where • Separate chaining • make a chain of all the elements that hash to a given location

  49. Open Addressing • Put item somewhere else in the array • Need to be able to find it again • need some rules that can be followed • Stupid rules make things very bad! • Clever rules perform very well • clever rules are hard to describe/understand • Java uses open addressing with clever rules

  50. 41 / 27 / 94 / 37 58 / / 78 * Chained Hash Tables • Array elements are linked lists instead of data element pointers • data stored in nodes 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 / * / / / / / * / / / / / / * / / * * /

More Related