Maps; Binary Search Trees

Transcription

1 Maps; Binary Search Trees PIC 10B Friday, May 20, 2016 PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

2 Overview of Lecture 1 Maps 2 Binary Search Trees 3 Questions PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

3 From Last Time Recall the problem from last lecture: you are making flashcards for a language class and want to have an efficient system of checking if you already have a flashcard, or if you need to insert a new card. We saw how std::set can be used for efficient searching, insertion, and deletion. However, std::set only allows us to check if we have an entry for a word. What if we want to store the definition of a word along with the word? PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

4 The std::map Container The std::map container stores pairs of keys and values. Each key is stored in the data structure, just like a std::set. Each key also has an associated value. In our flashcard example, we might have the following key/value pairs: key hola adios gracias value hello goodbye thank you Each key must have a unique value, but different keys may be associated to the same value. key pesado ponderado value heavy heavy PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

5 std::map Operations # include <map >... // Declare a map which has keys and values which are strings std :: map < std :: string, std :: string > dict ; dict [" hola "] = " hello "; // the key " hola " maps to " hello " dict. insert ( std :: pair < std :: string, std :: string > (" adios ", " goodbye ")) // " adios " maps to " goodbye " int count ; // count occurances of a key count = dict. count (" hola "); // count = 1 count = dict. count (" gracias "); // count = 0 std :: map < std :: string, std :: string >:: iterator it; it = dict. find (" hola "); // it points to entry for " hola " std :: string key = it -> first ; // key = " hola " std :: string val = it -> second ;// val = " hello " it = dict. find (" gracias "); // it = dict. end () it = dict. find (" adios "); dict. erase ( it ); // remove entry at iterator dict. erase (" hola "); // remove entry by key PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

6 Complexity of std::map Operations If an std::map contains n (distinct) keys: operation runtime access element (operator[]) O(log n) insert element (insert()) O(log n) erase element (erase()) O(log n) All of these operations are very efficient, but... Question the key data type must have operator< defined! How are the search/insert/erase operations so efficient (O(log n)) for std::set and std::map??? PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

7 Binary Search Trees Previously we saw vector/array and linked list data types. In both cases, data is stored linearly. Sorted vectors/arrays allowed for fast searching (if sorted), but slow insertion/deletion. Linked lists allowed for fast insertion/deletion, but slow searching. How can we get fast insertion and searching? Use a binary search tree! PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

8 Binary Search Trees Suppose we want to store a set of numbers for easy access. We should organize them in a tree: PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

9 Properties of Binary Search Tree Has a unique root at the top of the tree. Each node has a (possibly empty) left child, right child, and parent. The root has no parent. A node with no children is a leaf The value stored at a node is: 1 larger than every value in the sub-tree rooted at its left child 2 smaller than every value in the sub-tree rooted at its right child The height of a tree is the length of the longest path from the root to a leaf. PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

10 Searching a BST How would we check if the tree contains the value 14? Start at the root, which stores the value 22. Since 14 < 22, 14 must be in the left subtree. Examine the left child of 22, which contains > 10 so 14 must be to the right of < 16 so 14 must be to the left of > 13 so 14 must be to the right of 13. But 13 doens t have a right child, so 14 is not in the tree! PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

11 Searching a BST How would we check if the tree contains the value 14? Contains 14? < > < != 13, so no! PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

12 Insertion into a BST Since we didn t find 14 in the BST, how could we insert it? Just add it where we failed to find it! is now the right child of 13. PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

13 Deletion from a BST Deletion is a bit tricker than search/insertion because we need to maintain the properties of a BST... Let s start with the easiest case: Erase a leaf just remove the node that stores it! Erasing 43: PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

14 Deletion from a BST Deletion is a bit tricker than search/insertion because we need to maintain the properties of a BST... Let s start with the easiest case: Erase a leaf just remove the node that stores it! Erasing 43: PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

15 Deletion from a BST To delete a node with a single child, just replace the deleted node with its child Deleting 13. After the removal, 14 is the left child of 16. PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

16 Deletion from a BST How to delete a node with two children? How would we delete 10? PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

17 Deletion from a BST How would we delete 10? Find the next smallest element after 10 in the tree (14) Replace 10 with 14 Remove the node containing 14 PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

18 Deletion from a BST The BST after deleting 10: PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

19 Efficiency of Operations Suppose we have a BST of height h that is, h is the longest distance from the root to a leaf. Then the BST operations have the following runtimes: operation search insert erase runtime O(h) O(h) O(h) PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

20 Relationship Between Height and Size The runtimes of the basic BST operations are O(h). But what are they in terms of the size n (number of elements contained in the BST)? The height h can be as large as n 1. The height h can be as small as log n. This is a HUGE range! PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

21 An Unbalaced BST This is bad! The height of the tree is h = n 1, so all operations are O(n) this is as bad as a linked list! PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

22 Balanced BSTs This BST contains the same elements as the previous slide: Notice how all leaves are the same distance from the root (2). A BST is (height) balanced if: 1 Only nodes at distance h 1 can have fewer than 2 children, and 2 the distances from an pair of leaves to the root differ by at most one. The tree above is balanced, while the one from the previous slide is not balanced. PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

23 Balanced BSTs In a balanced BST, since every node at distance less than h 1 from the root has 2 children, the tree must have at least nodes. Thus: h 1 = 2 h 1 A balanced BST of height h has n 2 h 1 nodes. Therefore, h = O(log n). As a consequence the runtime for search/insert/erase is O(h) = O(log n). Therefore balanced BSTs are AWESOME! std::set and std::map use balanced BSTs to store their elements! Insertion and deletion are more complicated to maintain the balance, but they still run in time O(h) = O(log n). PIC 10B Maps; Binary Search Trees Friday, May 20, / 24

24 Questions 1 Make a flashcard program that allows the user to make flashcards for learning a foreign language. You should use std::map to store the keys and values for the flashcards. How might you save the contents of the std::map in order let the user load flashcards from a previous session? 2 Starting with an empty BST, create a BST by inserting the following numbers in the order they are written: 3, 2, 1, 5, 10, 4, 9, 7, 6, 8 Is the BST you obtain balanced? If not, make a balanced BST with the same contents as above. 3 Think about how to design an algorithm that takes a possible unbalanced BST and creates a balanced BST with the same contents. PIC 10B Maps; Binary Search Trees Friday, May 20, / 24