From 9165b35d82a7e594502d1fcc458d7ddfd06c0d52 Mon Sep 17 00:00:00 2001 From: Jidong Xiao Date: Thu, 26 Oct 2023 10:25:39 -0400 Subject: [PATCH] adding lecture 17 --- lectures/17_trees_I/README.md | 137 ++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 lectures/17_trees_I/README.md diff --git a/lectures/17_trees_I/README.md b/lectures/17_trees_I/README.md new file mode 100644 index 0000000..90ea76b --- /dev/null +++ b/lectures/17_trees_I/README.md @@ -0,0 +1,137 @@ +# Lecture 17 --- Trees, Part I + +## 17.1 Standard Library Sets + +- STL sets are ordered containers storing unique “keys”. An ordering relation on the keys, which defaults to +operator<, is necessary. Because STL sets are ordered, they are technically not traditional mathematical sets. +- Sets are like maps except they have only keys, there are no associated values. Like maps, the keys are constant. +This means you can’t change a key while it is in the set. You must remove it, change it, and then reinsert it. +- Access to items in sets is extremely fast! O(log n), just like maps, but sets do not have the [] operator, and +you shouldn’t use [] to access elements in a set. +- Like other containers, sets have the usual constructors as well as the size member function. + +## 17.2 Set iterators + +- Set iterators, similar to map iterators, are bidirectional: they allow you to step forward (++) and backward +(--) through the set. Sets provide begin() and end() iterators to delimit the bounds of the set. +- Set iterators refer to const keys (as opposed to the pairs referred to by map iterators). For example, the +following code outputs all strings in the set words: + +```cpp +for (set::iterator p = words.begin(); p!= words.end(); ++p) +cout << *p << endl; +``` + +## 17.3 Set insert + +- There are two different versions of the insert member function. The first version inserts the entry into the +set and returns a pair. The first component of the returned pair refers to the location in the set containing the +entry. The second component is true if the entry wasn’t already in the set and therefore was inserted. It is +false otherwise. The second version also inserts the key if it is not already there. The iterator pos is a “hint” +as to where to put it. This makes the insert faster if the hint is good. + +```cpp +pair set::insert(const Key& entry); +iterator set::insert(iterator pos, const Key& entry); +``` + +## 17.4 Set erase +- There are three versions of erase. The first erase returns the number of entries removed (either 0 or 1). The +second and third erase functions are just like the corresponding erase functions for maps. Note that the erase +functions do not return iterators. This is different from the vector and list erase functions. + +```cpp +size_type set::erase(const Key& x); +void set::erase(iterator p); +void set::erase(iterator first, iterator last); +``` + +## 17.5 Set find +- The find function returns the end iterator if the key is not in the set: + +```cpp +const_iterator set::find(const Key& x) const; +``` + +## 17.6 Beginning our implementation of ds set: The Tree Node Class + +- Here is the class definition for nodes in the tree. We will use this for the tree manipulation code we write. + +```cpp +template class TreeNode { +public: + TreeNode() : left(NULL), right(NULL) {} + TreeNode(const T& init) : value(init), left(NULL), right(NULL) {} + T value; + TreeNode* left; + TreeNode* right; +}; +``` + +- Note: Sometimes a 3rd pointer — to the parent TreeNode — is added. + +## 17.7 Exercises + +1. Write a templated function to find the smallest value stored in a binary search tree whose root node is pointed +to by p. +\\ +\\ +\\ +\\ + + +2. Write a function to count the number of odd numbers stored in a binary tree (not necessarily a binary search +tree) of integers. The function should accept a TreeNode pointer as its sole argument and return an +integer. Hint: think recursively! + +## 17.8 ds_set and Binary Search Tree Implementation + +- A partial implementation of a set using a binary search tree is in the code attached. We will continue to study +this implementation in Lab 10 & the next lecture. +- The increment and decrement operations for iterators have been omitted from this implementation. Next week +in lecture we will discuss a couple strategies for adding these operations. +- We will use this as the basis both for understanding an initial selection of tree algorithms and for thinking +about how standard library sets really work. + +## 17.9 ds_set: Class Overview + +- There is two auxiliary classes, TreeNode and tree_iterator. All three classes are templated. +- The only member variables of the ds_set class are the root and the size (number of tree nodes). +- The iterator class is declared internally, and is effectively a wrapper on the TreeNode pointers. + – Note that operator* returns a const reference because the keys can’t change. + + – The increment and decrement operators are missing (we’ll fill this in next week in lecture!). + +- The main public member functions just call a private (and often recursive) member function (passing the root +node) that does all of the work. +- Because the class stores and manages dynamically allocated memory, a copy constructor, operator=, and +destructor must be provided. + +## 17.10 Exercises + +1. Provide the implementation of the member function ds_set::begin. This is essentially the problem of +finding the node in the tree that stores the smallest value. + + + + +2. Write a recursive version of the function find. + +## 17.11 In-order, Pre-Order, Post-Order Traversal + +- One of the fundamental tree operations is “traversing” the nodes in the tree and doing something at each node. +The “doing something”, which is often just printing, is referred to generically as “visiting” the node. +- There are three general orders in which binary trees are traversed: pre-order, in-order and post-order. + In order to explain these, let’s first draw an “exactly balanced” binary search tree with the elements 1-7: + – What is the in-order traversal of this tree? Hint: it is monotonically increasing, which is always true for +an in-order traversal of a binary search tree! + + + + – What is the post-order traversal of this tree? Hint, it ends with “4” and the 3rd element printed is “2”. + + + + – What is the pre-order traversal of this tree? Hint, the last element is the same as the last element of the +in-order traversal (but that is not true in general! why not?) +