Maps & Dictionaries Searching for Information

Transcription

1 Maps & Dictionaries Searching for Information Maps 1

2 Definition Map is the mathematical name for a dictionary» It is a function that, given a key, returns corresponding data > Hence the notion of mapping the key to the data» A standard dictionary maps words to their meaning A Map element consists of» A key that is a unique identifier for every entry in a map» The data (definition) that corresponds to the key > Often a pointer to the actual data Maps 2

3 Find an entry in a map Partial Interface findentry ( searchkey : KeyType ) : EntryType Require searchkey Void Ensure Result Void Result map Result.key = searchkey Result = Void Result map Maps 3

4 Partial Interface 2 Insert a new entry into a map insert ( entry : EntryType) Require ~ full entry map Ensure entry map Remove an entry from a map remove ( key : KeyType ) : EntryType Require entry map entry.key = key Ensure Result = entry Result map Maps 4

5 Sequential Search Properties If any of the following are true, then a sequential search must be made» The data is unordered by key» Only the = relationship is available, not < or > > An English person can verify equality of Greek, Russian or Cantonese words but without special knowledge are unable to say if one word is earlier than another in lexicographic order» The variance time is high for random access > The time to go from location j to location k is significantly different if j and k are close together than if they are far apart It is for that reason binary search is ineffective on linked lists Maps 5

6 General Search Entities Have a searchkey and a map Have the following sets of entities» total_search_set > All the entities in the map» searched_set > The set of entities that have been examined» to_search_set > The set of entities that are yet to be examined Invariant» total_search_set = searched_set + to_search_set Maps 6

7 General Search Algorithm findentry ( searchkey : KeyType ) : EntryType is to_search_set total_search_set Result select_an_entry ( to_search_set ) Loop Invariant k : searched_set k.key searchkey while Result Void Result.key searchkey do to_search_set to_search_set \ Result searched_set searched_set { Result } Result select_an_entry ( to_search_set ) end end Maps 7

8 Sequential Search Search for position from the front Θ ( Set_size )» Loop invariant k : head.. pred(p) k.key searchkey Maps 8

9 Sequential Search on Arrays total_search_set in locations 0.. size 1 searched_set in locations 0.. p 1 to_search_set in locations p.. size 1 findentry ( key : keytype ) : EntryType is p 0 ; Result array [ p ] Loop Invariant k : 0.. p 1 k.key searchkey Have a void value at array[size] to simplify the algorithm while Result Void Result.key searchkey do p++ // Changes both searched and to search sets Result array [ p ] end end Maps 9

10 Sequential Search on Lists total_search_set in locations head.. last searched_set in locations head.. pred ( p ) to_search_set in locations p.. last findentry ( key : keytype ) : EntryType is Result head Loop Invariant k : head.. pred ( p ) k.key searchkey end while Result Void Result.key searchkey do Result successor [ p ] end Maps 10

11 Insert and Remove for Sequential Search The algorithms are those that you have seen before in the notes on the Sequence ADT.» Circular array > Θ ( 1 ) for insert can do at either end, since items are unsorted > Θ ( length ) for remove must search & shift entries» Linked list > Θ ( 1 ) for insert can do at either end, since items are unsorted > Θ ( length ) for remove must search Maps 11

12 Binary Search Properties If ALL of the following are true, then a binary search can be made» The data is sorted by key» Besides = at least one of the relationships < or > are available» The variance time is low for random access to any data item > For arrays random access is cheap > For trees the equivalent to random access is following the pointers, which is also cheap Following one of a set of pointers is equivalent to dividing an interval. In trees we can usually do better than 1 and the rest, which is what sequential search does. Maps 12

13 Sequence Binary Search Time Θ ( log N ) is due to cutting search space in half on every iteration Maps 13

14 Array Binary Search total_search_set in locations head.. last searched_set in locations head.. low 1 high+1.. last to_search_set in locations low.. high Loop Invariant k : ( head.. low 1 ) ( high+1.. last ) k.key searchkey findentry( searchkey : KeyType ; low, high : Integer ) : EntryType is if low > high then Result Void ; return fi mid ( low + high ) / 2 ; Result = array [ mid ] fi end if Result.key searchkey then if Result.key > searchkey then Result findentry ( searchkey, low, mid 1 ) else Result findentry ( searchkey, mid + 1, high ) fi Maps 14

15 Insert & Remove Array Binary Search Θ ( N ) for insert» Θ ( log N ) to search for insertion point» Θ ( N ) to shift for insertion Θ ( N ) for remove» Θ ( log N ) to search for entry to remove» Θ ( N ) to shift to close the gap Maps 15

16 Binary Search Trees The linked list equivalent of binary search on arrays The pointers are pre-computed functions that give us the sub-tree in the half to search» No need to do mid ( low + high ) / 2 Maps 16

17 Binary Search Trees 2 to_search_set is always the sub-tree from the current node searched_set = total_search_set / to_search_set Search for C Maps 17

18 Binary Search Trees 3 total_search_set in locations tree at root searched_set in locations tree at root \ tree at node to_search_set in locations tree at node Loop Invariant k : tree at root \ tree at node k.key searchkey findentry( searchkey : KeyType, root : Node ) : EntryType is if root = Void then Result Void ; return fi fi end if Result.entry.key searchkey then if root.key > searchkey then Result findentry ( searchkey, root.left ) else Result findentry ( searchkey, root.right ) fi else Result root.entry Maps 18

19 BST Search Complexity The time complexity depends heavily on the shape of the tree» Tree well balanced Θ ( log N ) > Every decision reduces the number of keys in half» Tree is poorly balanced Θ ( N ) > Tree becomes a linear list in the worst case The shape depends upon how the tree was built» The order of insertion and removal is critical» For random key order, expected performance is close to a balanced tree Maps 19

20 Insert into BST Insertion is based on the search algorithm» Search for where the entry would be if it were a leaf» Insert it as a new leaf Time complexity depends on the search time see previous slide Maps 20

21 Insert into BST 2 Maps 21

22 Insert into BST Algorithm insert( key : KeyType, data : DataType ) is newnode Node ( key, data ) if root = Void then root newnode fi end else insert_recursive ( root, newnode ) Maps 22

23 Insert into BST Algorithm 2 Insert_recursive ( root : Node, newnode : Node ) is if root. entry. key > newnode. entry. key then if root. left = Void then root. left newnode fi end else insert_recursive ( root. left, newnode ) fi else if root. right = Void then root. right newnode fi else insert_recursive ( root. right, newnode ) Maps 23

24 Remove from BST Removal is more complex as we may have to remove a node with two children» If no children > Remove from the tree by setting a null pointer in the parent logically the same as the next case» If one child > Remove from the tree by setting the child pointer in the parent to the child of the node to remove» If two children > Replace the entry with an inorder neighbour (left or right) > Remove the neighbour node Neighbour can have at most one child Maps 24

25 Remove from BST 2 Maps 25

26 Remove from BST 3 Maps 26

27 Remove from BST 4 Maps 27

28 Remove from BST 5 Maps 28

29 Remove from BST 6 Another view» The inorder listing for theprevious tree» To remove 50 replace with either 30 or 52, an inorder neighbour, then remove the neighbour node An inorder neighbour of a node with two children can have at most one child, otherwise it would not be a neighbour Maps 29

30 Remove from BST Algorithm We need three pieces of information» A pointer to the parent > To change a pointer in the parent > If the node to delete is the root, then the parent is void» A pointer to the child > To get pointers to its sub-trees» Whether the child is a left or right child of the parent > To change the correct pointer in the parent Maps 30

31 Remove from BST Algorithm 2 remove ( key : KeyType ) : EntryType is parent findparent ( key ) // Leave as exercise fi end // variation on findentry if parent = void then Result removeroot elseif parent.left.entry.key = key then Result remove_left_child ( parent ) else Result remove_right_child ( parent ) Maps 31

32 Remove BST root removeroot : EntryType is Result root.entry if root.left = Void then root root.right // case 2 elseif root.right = Void then root root.left // case 1 else swap_and_remove_left_neighbour ( root ) // case 3 fi end Maps 32

33 remove_left_child ( parent ) remove_left_child ( parent : Node ) : EntryType is child parent.left Result child.entry if child.left = Void then parent.left child.right elseif child.right = Void then parent.left child.left else swap_and_remove_right_neighbour ( child ) fi end Maps 33

34 remove_right_child ( parent ) remove_right_child ( parent : Node ) : EntryType is child parent.right Result child.entry if child.left = Void then parent.right child.right elseif child.right = Void then parent.right child.left else swap_and_remove_left_neighbour ( child ) fi end Help keep the tree balanced by swapping with left and right in remove Maps 34

35 swap_and_remove_left_neighbour ( parent ) swap_and_remove_left_neighbour ( parent : Node ) is child parent.left // Child has no right sub-tree is a special case fi end if child.right = Void then parent.entry child.entry parent.left child.left else // Search child right sub-tree see next slide parent To remove 48 move up 35 child Maps 35

36 swap_and_remove_left_neighbour ( parent ) 2 // Search child right sub-tree put program text into previous slide while child.right.right Void do child child.right end parent.entry child.right.entry child.right child.right.left parent child To remove 48 move up 45 Maps 36