fix(book/set): split Set chapter into Hash Set and Tree Set for better

coverage

Author: amejiarosario

README.md

@@ -271,8 +271,8 @@ Use Linked Lists when:
 #### [HashMaps](book/content/part03/map.asc)
 
 Learn how to implement different types of Maps such as:
-- [HashMap](book/content/part03/hashmap.asc)
-- [TreeMap](book/content/part03/treemap.asc)
+- [HashMap](book/content/part02/hash-map.asc)
+- [TreeMap](book/content/part03/tree-map.asc)
 
 Also, [learn the difference between the different Maps implementations](book/content/part03/time-complexity-graph-data-structures.asc):
 

book/B-self-balancing-binary-search-trees.asc

@@ -36,8 +36,8 @@ Let's go one by one.
 
 Right rotation moves a node on the right as a child of another node.
 
-Take a look at the `@example` in the code below.
-As you can see we have an unbalanced tree `4-3-2-1`.
+Take a look at the examples in the code in the next section.
+As you will see we have an unbalanced tree `4-3-2-1`.
 We want to balance the tree, for that we need to do a right rotation of node 3.
 So, we move node 3 as the right child of the previous child.
 
@@ -140,4 +140,3 @@ This rotation is also referred to as `RL rotation`.
 === Self-balancing trees implementations
 
 So far, we have study how to make tree rotations which are the basis for self-balancing trees. There are different implementations of self-balancing trees such a Red-Black Tree and AVL Tree.
-

book/D-interview-questions-solutions.asc

@@ -438,7 +438,7 @@ The complexity of any of the BFS methods or DFS is similar.
 
 [#hashmap-q-two-sum]
 include::content/part02/hash-map.asc[tag=hashmap-q-two-sum]
-// include::content/part03/hashmap.asc[tag=hashmap-q-two-sum]
+// include::content/part02/hash-map.asc[tag=hashmap-q-two-sum]
 
 This simple problem can have many solutions; let's explore some.
 
@@ -482,7 +482,7 @@ include::interview-questions/two-sum.js[tags=description;solution]
 
 [#hashmap-q-subarray-sum-equals-k]
 include::content/part02/hash-map.asc[tag=hashmap-q-subarray-sum-equals-k]
-// include::content/part03/hashmap.asc[tag=hashmap-q-subarray-sum-equals-k]
+// include::content/part02/hash-map.asc[tag=hashmap-q-subarray-sum-equals-k]
 
 This problem has multiple ways to solve it. Let's explore some.
 
@@ -590,7 +590,7 @@ The sum is 1, however `sum - k` is `0`. If it doesn't exist on the map, we will
 
 
 [#set-q-most-common-word]
-include::content/part03/set.asc[tag=set-q-most-common-word]
+include::content/part02/hash-set.asc[tag=set-q-most-common-word]
 
 This problem requires multiple steps. We can use a `Set` for quickly looking up banned words. For getting the count of each word, we used a `Map`.
 
@@ -632,7 +632,7 @@ include::interview-questions/most-common-word.js[tags=explicit]
 
 
 [#set-q-longest-substring-without-repeating-characters]
-include::content/part03/set.asc[tag=set-q-longest-substring-without-repeating-characters]
+include::content/part02/hash-set.asc[tag=set-q-longest-substring-without-repeating-characters]
 
 One of the most efficient ways to find repeating characters is using a `Map` or `Set`. Use a `Map` when you need to keep track of the count/index (e.g., string -> count) and use a `Set` when you only need to know if there are repeated characters or not.
 

book/content/part02/hash-map.asc

@@ -5,7 +5,7 @@ endif::[]
 
 (((Map))) (((HashMap))) (((HashTable))) (((Data Structures, Linear, HashMap)))
 [[hashmap-chap]]
-=== Hash Map
+=== Map
 
 A Map is a data structure where a `key` is mapped to a `value`. It's used for a fast lookup of values based on the given key. Only one key can map to a value (no duplicates).
 
@@ -35,6 +35,7 @@ A Map uses an array internally. It translates the key into an array's index usin
 
 JavaScript has two ways to use Maps: one uses objects (`{}`), and the other is using the built-in `Map`.
 
+[[hashmap-examples]]
 .Using Objects as a HashMap.
 [source, javascript]
 ----

book/content/part02/hash-set.asc

@@ -0,0 +1,188 @@
+ifndef::imagesdir[]
+:imagesdir: ../../images
+:codedir: ../../../src
+endif::[]
+
+(((Set))) (((Data Structures, Non-Linear, Set)))
+[[hash-set-chap]]
+=== Set
+Set is a data structure that allows you to store unique values. If you try to add the same value, multiple times only one instance will be added. Also, you can check very quickly if a value exists or not. Searching by value on arrays takes `O(n)`. However, searching by value on a Set takes `O(1)` on average.
+
+A Set can be implemented on different ways. One way it's using a <<hashmap-chap, Hash Map>> and other is using a <<tree-map-chap, Tree Map>>. JavaScript has a built-in Hash Set, so that' the one we are going to focus on.
+
+TIP: We will go more in details with <<tree-map-chap, Tree Map>> after we cover the <<binary-search-tree-chap>>.
+
+
+==== Set vs Array
+
+An array allows you to search a value by index in constant time `O(1)`, however if you don't know the index, searching a value would take you linear time `O(n)`. A Set has doesn't allow you to search value by index, but you can search by value in constant time. The `Set.add` and `Set.has` method both are `O(1)` in average.
+
+Take a look at the following examples:
+
+.Set usage example (using JavaScript built-in Set)
+[source, javascript]
+----
+const set = new Set();
+
+set.add(1); //↪️ Set [ 1 ]
+set.add(1); //↪️ Set [ 1 ]
+set.add(2); //↪️ Set [ 1, 2 ]
+set.add(3); //↪️ Set [ 1, 2, 3 ]
+set.has(1); //↪️ true
+set.delete(1); //↪️ removes 1 from the set
+set.has(1);    //↪️ false, 1 has been removed
+set.size; //↪️ 2, we just removed one value
+console.log(set); //↪️ Set(2) {2, 3}
+----
+
+As you can see, even if we insert the same value multiple times, it only gets added once.
+
+Similar to a <<hashmap-examples, map>>, you can also insert objects and any kind of objects. However, be careful, because anything that is not a number, string or symbol would be matched by reference. Let's do some examples.
+
+.Using a Set with objects
+[source, javascript]
+----
+const set = new Set();
+
+set.add({a: 1, b: 2});
+set.has({a: 1, b: 2}); // ↪️ false
+
+const a = {a: 1, b: 2};
+set.add(a);
+set.has(a); // ↪️ true
+
+console.log(set); // Set { [ 1, 2, 3 ], [ 1, 2, 3 ] }
+----
+
+As you can see, you can't to find object using a new object (e.g. `{a: 1, b: 2}`), you need the reference to find it.
+If you need to match by value, you would need to convert it to an string using `JSON.stringify`.
+
+.Workaround to find objects by value.
+[source, javascript]
+----
+const set = new Set();
+
+set.add(JSON.stringify({a: 1, b: 2}));
+
+set.has(JSON.stringify({a: 1, b: 2})); // ↪️ true
+
+console.log(set); // Set { '{"a":1,"b":2}' }
+----
+
+
+==== Removing duplicates from an array.
+
+One common case for a Set is to eliminate duplicates from an array.
+
+.Removing duplicates from an array
+[source, javascript]
+----
+const arr = [1, 2, 2, 1, 3, 2];
+
+// convert array to set
+const set = new Set(arr);
+// convert set to array
+const uniqueValues = Array.from(set);
+// check array
+console.log(uniqueValues); // [ 1, 2, 3 ]
+----
+
+You can also do it all in one line.
+
+.One-liner to remove duplicates from array.
+[source, javascript]
+----
+const arr = [1, 2, 2, 1, 3, 2];
+console.log([...new Set(arr)]); // [ 1, 2, 3 ]
+----
+
+==== Time Complexity of a Hash Set
+
+All operation on Hash Set are constant time on average: `O(1)`. Similar to the Hash Map, there are cases when the the Set is getting full and it would do a rehash taking `O(n)` for that one insertion.
+
+// tag::table[]
+.Time complexity HashSet
+|===
+.2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
+^|_Index/Key_ ^|_Value_
+| Hash Set ^|O(1) ^|- ^|O(1)* ^|O(1) ^|O(n)
+|===
+{empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
+// end::table[]
+
+
+==== Practice Questions
+(((Interview Questions, Set)))
+
+// tag::set-q-most-common-word[]
+===== Most common word
+
+*ST-1*) _Given a text and a list of banned words.
+Find the most common word that is not on the banned list.
+You might need to sanitize the text and strip out punctuation `?!,'.`_
+// end::set-q-most-common-word[]
+
+// _Seen in interviews at: Amazon._
+
+Examples:
+
+[source, javascript]
+----
+mostCommonWord(
+  `How much wood, would a Woodchuck chuck,
+  if a woodchuck could chuck?`,
+  ['a'],
+); // woodchuck or chuck (both show up twice)
+
+mostCommonWord(
+`It's a blue ball and its shade... Very BLUE!`,
+['and']); // blue (it show up twice, "it" and "its" once)
+----
+
+Starter code:
+
+[source, javascript]
+----
+include::../../interview-questions/most-common-word.js[tags=description;placeholder]
+----
+
+
+_Solution: <<set-q-most-common-word>>_
+
+
+
+
+
+
+
+
+
+
+
+// tag::set-q-longest-substring-without-repeating-characters[]
+===== Longest Without Repeating
+
+*ST-2*) _Find the length of the longest substring without repeating characters._
+
+// end::set-q-longest-substring-without-repeating-characters[]
+
+// _Seen in interviews at: Amazon, Facebook, Bloomberg._
+
+Examples:
+
+[source, javascript]
+----
+lenLongestSubstring('aaaaa'); // 1 ('a')
+lenLongestSubstring('abccdefg'); // 5 ('cdefg')
+lenLongestSubstring('abc'); // 3 ('abc')
+----
+
+Starter code:
+
+[source, javascript]
+----
+include::../../interview-questions/longest-substring-without-repeating-characters.js[tags=description;placeholder]
+----
+
+
+_Solution: <<set-q-longest-substring-without-repeating-characters>>_

book/content/part03/binary-search-tree.asc

@@ -3,10 +3,12 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
-=== Binary Search Tree
 (((Binary Search Tree)))
 (((BST)))
 (((Data Structures, Non-Linear, Binary Search Tree)))
+[[binary-search-tree-chap]]
+=== Binary Search Tree
+
 
 .To recap, the Binary Search Tree (BST) is a tree data structure that keeps the following constraints:
 * Each node must have at most two children. Usually referred to as "left" and "right".

book/content/part03/graph-search.asc

@@ -187,6 +187,11 @@ graph G {
     c0, c1, c2 [color=midnightblue]
     // c3 [color=red]
   }
+
+  a0, b0, c0 [label = 0]
+  a1, b1, c1 [label = 1]
+  a2, b2, c2 [label = 2]
+  b3, c3 [label = 3]
 }
 ....
 

book/content/part03/graph.asc

@@ -200,7 +200,7 @@ include::{codedir}/data-structures/graphs/graph.js[tag=addVertex, indent=0]
 
 If the node doesn't exist, then we create the new node and add it to a `HashMap`.
 
-TIP: <<part03-graph-data-structures#map>> stores key/pair value very efficiently. Lookup is `O(1)`.
+TIP: <<tree-map-chap>> stores key/pair value very efficiently. Lookup is `O(1)`.
 
 The `key` is the node's value, while the `value` is the newly created node.
 

book/content/part03/set.asc

@@ -16,10 +16,10 @@ In this section, we learned about Graphs applications, properties and how we can
 | <<part03-graph-data-structures#bst, BST (unbalanced)>> ^|- ^|O(n) ^|O(n) ^|O(n) ^|O(n)
 | <<b-self-balancing-binary-search-trees, BST (balanced)>> ^|- ^|O(log n) ^|O(log n) ^|O(log n) ^|O(n)
 | Hash Map (naïve) ^|O(n) ^|O(n) ^|O(n) ^|O(n) ^|O(n)
-| <<part03-graph-data-structures#hashmap, HashMap>> (optimized) ^|O(1) ^|O(n) ^|O(1)* ^|O(1) ^|O(n)
-| <<part03-graph-data-structures#treemap, TreeMap>> (Red-Black Tree) ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)
-| <<part03-graph-data-structures#hashset, HashSet>> ^|O(1) ^|- ^|O(1)* ^|O(1) ^|O(n)
-| <<part03-graph-data-structures#tree-set, TreeSet>> ^|O(log n) ^|- ^|O(log n) ^|O(log n) ^|O(n)
+| <<hashmap-chap, HashMap>> (optimized) ^|O(1) ^|O(n) ^|O(1)* ^|O(1) ^|O(n)
+| <<tree-map-chap, TreeMap>> (Red-Black Tree) ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)
+| <<hash-set-chap, HashSet>> ^|O(1) ^|- ^|O(1)* ^|O(1) ^|O(n)
+| <<tree-set-chap, TreeSet>> ^|O(log n) ^|- ^|O(log n) ^|O(log n) ^|O(n)
 |===
 {empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
 // end::table[]

book/content/part03/time-complexity-graph-data-structures.asc

@@ -67,8 +67,8 @@ image::image32.png[image,width=321,height=193]
 Binary trees are one of the most used kinds of trees, and they are used to build other data structures.
 
 .Binary Tree Applications
-- <<part03-graph-data-structures#map>>
-- <<part03-graph-data-structures#set>>
+- <<tree-map-chap>>
+- <<tree-set-chap>>
 - Priority Queues
 - <<part03-graph-data-structures#bst>>
 

book/content/part03/tree-intro.asc

@@ -4,17 +4,19 @@ ifndef::imagesdir[]
 endif::[]
 
 (((TreeMap))) (((Data Structures, Non-Linear, TreeMap))) (((Binary Search Tree))) (((BST)))
-[[treemap-chap]]
-=== TreeMap
+[[tree-map-chap]]
+=== Tree Map
 
-A Map is an abstract data structure to store pairs of data: *key* and *value*. It also has a fast key lookup of `O(1)` for <<hashmap-chap>> or `O(log n)` for <<treemap-chap>>.
+A Map is an abstract data structure to store pairs of data: *key* and *value*. It also has a fast key lookup of `O(1)` for <<hashmap-chap>> or `O(log n)` for <<tree-map-chap>>.
 
 We can implement a Map using two different underlying data structures:
 
 * *HashMap*: it’s a map implementation using an *array* and a *hash function*. The job of the hash function is to convert the `key` into an index that maps to the `value`. Optimized HashMap can have an average runtime of *O(1)*.
 * *TreeMap*: it’s a map implementation that uses a self-balanced Binary Search Tree (like <<c-avl-tree>> or Red-Black Tree). The BST nodes store the key, and the value and nodes are sorted by key guaranteeing an *O(log n)* look up.
 
-We already covered <<hashmap-chap>>, so this chapter we are going to focus on TreeMap.
+We already covered <<hashmap-chap, Hash Map>>, so this chapter we are going to focus on TreeMap.
+
+TIP: JavaScript only provides (Hash) `Map` that's enough for most needs. But we are going to implement a Tree Map so it's more clear how it works and when it should be used.
 
 A TreeMap is a Map implementation using a Balanced Binary Search Trees.
 Implementing a Map with a tree, TreeMap, has a couple of advantages over a HashMap:
@@ -24,7 +26,6 @@ Implementing a Map with a tree, TreeMap, has a couple of advantages over a HashM
 * Collisions are not a concern so in the worst case is still *O(log n)*.
 * Trees are more space efficient and don’t need to allocate memory beforehand (e.g. `HashMap`’s initial capacity) nor you have to rehash when is getting full.
 
-indexterm:[Runtime, Logarithmic]
 Ok, now that you know the advantages, let’s implement it!
 For a full comparison read the <<HashMap vs TreeMap>> section.
 
@@ -103,7 +104,6 @@ The BST implementation does all the heavy lifting.
 That’s it! To see the full file in context, click here: https://github.com/amejiarosario/dsa.js/blob/f69b744a1bddd3d99243ca64b3ad46f3f2dd7342/src/data-structures/maps/tree-maps/tree-map.js#L22[here]
 
 
-<<<
 ==== HashMap vs TreeMap
 
 .A map can be implemented using hash functions or binary search tree:
@@ -130,7 +130,7 @@ As we discussed so far, there is a trade-off between the implementations.
 .2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
 ^|_Index/Key_ ^|_Value_
 | <<hashmap-chap, Hash Map>> ^|O(1) ^|O(n) ^|O(1)* ^|O(1) ^|O(n)
-| <<treemap-chap, Tree Map (Red-Black Tree)>> ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)
+| <<tree-map-chap, Tree Map (Red-Black Tree)>> ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)
 |===
 {empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
 // end::table[]

book/content/part03/treemap.asc renamed to book/content/part03/tree-map.asc

@@ -0,0 +1,141 @@
+ifndef::imagesdir[]
+:imagesdir: ../../images
+:codedir: ../../../src
+endif::[]
+
+(((TreeSet)))
+(((Data Structures, Non-Linear, TreeSet)))
+[[tree-set-chap]]
+=== Tree Set
+
+A tree set is a data structure that stores unique values and keep them sorted. You can get check if a value exists in `O(log n)` time.
+
+Another way to implement a Set is using a hash function, as we covered on <<hash-set-chap, Hash Set>>. There are some key differences between the two implementations.
+
+==== HashSet vs TreeSet
+
+We can implement a `map` using a *<<b-self-balancing-binary-search-trees, balanced BST>>* or a *<<hashmap-chap,hash function>>*. If we use them to implement a `Set`, we would have a `HashSet` and `TreeSet`. As all data structures there are trade-offs. Here are some key differences:
+
+* `TreeSet`, would return the values sorted in ascending order.
+* `HashSet`, would return the values in insertion order.
+* Operations on a `HashSet` would take on average O(1), and in the worst case (rehash is due), it would take O(n).
+* Operation on a `TreeSet` is always O(log n).
+
+==== Time Complexity Hash Set vs Tree Set
+
+(((Tables, Non-Linear DS, HashSet/TreeSet complexities)))
+indexterm:[Runtime, Linear]
+(((Logarithmic)))
+(((Runtime, Logarithmic)))
+
+// also on: book/content/part03/time-complexity-graph-data-structures.asc
+// tag::table[]
+.Time complexity HashSet vs TreeSet
+|===
+.2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
+^|_Index/Key_ ^|_Value_
+| <<hash-set-chap, Hash Set>> ^|O(1) ^|- ^|O(1)* ^|O(1) ^|O(n)
+| <<tree-set-chap, Tree Set>> ^|O(log n) ^|- ^|O(log n) ^|O(log n) ^|O(n)
+|===
+{empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
+// end::table[]
+
+
+TIP: JavaScript only provides (Hash) `Set` that's enough for most needs. But we are going to implement a Tree Set so it's more clear how it works and when it should be used.
+
+==== Implementing a Tree Set
+
+
+.TreeSet's constructor method and size attribute
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/tree-set.js[tag=constructor]
+}
+----
+<1> Converts an array or any iterable data structure to a set.
+
+An everyday use case for Sets is to remove duplicated values from an array. We can do that bypassing them in the constructor as follows:
+
+.Removing duplicates from an Array using a Set
+[source, javascript]
+----
+set = new TreeSet([1, 2, 3, 2, 1]);
+expect(set.size).toBe(3);
+expect(Array.from(set.keys())).toEqual([1, 2, 3]);
+----
+
+Ok, now let’s implement the add method.
+
+===== Adding elements to a TreeSet
+
+For adding values to the set, we `Tree.add` method.
+
+.TreeSet's constructor method and size attribute
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/tree-set.js[tag=add,indent=0]
+----
+
+Our <<Inserting new elements in a BST, BST implementation>> can hold duplicated values. It has a multiplicity tally to keep track of duplicates. However, we don’t dupe in a set. For that, we check if the value is already in the tree.
+Don’t worry about adding extra lookups. The
+`Tree.has` is also very performant *O(log n)*.
+
+===== Searching for values in a TreeSet
+
+Again, we rely on the Tree implementation to do the heavy lifting:
+
+.TreeSet's `has` method
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/tree-set.js[tag=has, indent=0]
+----
+
+===== Deleting elements from a TreeSet
+
+We delete the elements from the TreeSet using the remove method of the BST.
+
+.TreeSet's `delete` method
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/tree-set.js[tag=delete, indent=0]
+----
+
+Voilà! That’s it!
+
+===== Converting TreeSet to Array
+
+Another use case for a Set is to convert it to an array or use an iterator (for loops, forEach, …). Let’s provide the method for that:
+
+.TreeSet's iterator
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/tree-set.js[tag=iterator, indent=0]
+----
+
+We are using the `inOrderTraversal` method of the BST to go each key in an
+ascending order.
+
+.JavaScript Built-in `Symbol` iterator
+****
+The `Symbol.iterator` built-in symbol specifies the default iterator for
+an object. Used by `for...of`, `Array.from` and others.
+****
+
+Now we can convert from set to array and vice versa easily. For
+instance:
+
+.TreeSet's iterator
+[source, javascript]
+----
+const array = [1, 1, 2, 3, 5];
+
+// array to set
+const set = new TreeSet(array);
+
+// set to array
+Array.from(set); //↪️ (4) [1, 2, 3, 5]
+----
+
+No more duplicates in our array!
+
+Check out our https://github.com/amejiarosario/dsa.js/blob/f69b744a1bddd3d99243ca64b3ad46f3f2dd7342/src/data-structures/sets/tree-set.js#L12[GitHub repo for the full TreeSet implementation].

book/content/part03/tree-set.asc

@@ -23,7 +23,7 @@ TIP: TL;DR: Don't start coding right away. First, solve the problem, then write
 .. If anything else fails, how would you solve it the dumbest way possible (brute force). We can optimize it later.
 . *Test* your algorithm idea with multiple examples
 . *Optimize* the solution –Only optimize when you have something working don't try to do both at the same time!
-.. Can you trade-off space for speed? Use a <<part03-graph-data-structures#hashmap>> to speed up results!
+.. Can you trade-off space for speed? Use a <<hashmap-chap>> to speed up results!
 .. Do you have a bunch of recursive and overlapping problems? Try <<Dynamic Programming>>.
 .. Re-read requirements and see if you can take advantage of anything. E.g. is the array sorted?
 . *Write Code*, yes, now you can code.

book/content/part04/algorithmic-toolbox.asc

@@ -0,0 +1,73 @@
+ifndef::imagesdir[]
+:imagesdir: ../../images
+:codedir: ../../../src
+endif::[]
+
+[[hashset]]
+==== Hash Set Implementation
+(((HashSet)))
+(((Data Structures, Non-Linear, HashSet)))
+The *HashSet* is the set implementation using a HashMap as its underlying data structure.
+
+The HashSet interface will be the same as the built-in `Set` or our previously implemented `TreeSet`.
+
+.HashSet's constructor method and size attribute
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/hash-set.js[tag=constructor]
+}
+----
+
+This constructor is useful for converting an array to set and initializing the `HashMap`.
+
+===== Inserting values to a HashSet
+
+To insert items in a HashSet, we use the `set` method of the `HashMap`:
+
+.HashSet's `add` method
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/hash-set.js[tag=add, indent=0]
+}
+----
+
+`HashMap` stores key/value pairs, but we only need the keys for Set, so we ignore the value.
+
+===== Finding values in a HashSet
+
+We use the method `has` to check if a value is on the `Set` or not.
+
+.HashSet's `has` method
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/hash-set.js[tag=has, indent=0]
+----
+
+Internally, the `HashMap` will convert the key into an array index using a hash function. If there’s something in the array index bucket, it will return
+true, and if it’s empty, it will be false.
+
+===== Deleting values from a HashSet
+
+For deleting a value from a hashSet, we use the HashMap’s delete method:
+
+.HashSet's `delete` method
+[source, javascript]
+----
+include::{codedir}/data-structures/sets/hash-set.js[tag=delete, indent=0]
+----
+
+This method has an average runtime of *O(1)*.
+
+==== HashSet vs HashMap Time Complexity
+
+We can say that `HashMap` in on average, more performant O(1) vs. O(log n). However, if a
+rehash happens, it will take *O(n)* instead of *O(1)*. A `TreeSet` is always *O(log n)*.
+
+
+
+To recap, HashSet and TreeSet will keep data without duplicates. The
+difference besides runtime is that:
+
+.TreeSet vs HashSet
+* HashSet keeps data in insertion order
+* TreeSet keeps data sorted in ascending order.

book/deprecated/old-set.asc

@@ -10,6 +10,7 @@ When you are aware of the data structures implementations, you spot when to use
 .In this part we are going to learn about the following linear data structures:
 - <<array-chap>>
 - <<hashmap-chap>>
+- <<hash-set-chap>>
 - <<part02-linear-data-structures#linked-list>>
 - <<part02-linear-data-structures#stack>>
 - <<part02-linear-data-structures#queue>>
@@ -31,6 +32,9 @@ include::content/part02/array.asc[]
 <<<
 include::content/part02/hash-map.asc[]
 
+<<<
+include::content/part02/hash-set.asc[]
+
 <<<
 include::content/part02/linked-list.asc[]
 

book/part02-linear-data-structures.asc

@@ -1,13 +1,13 @@
 [[part03-graph-data-structures]]
-== Graph Data Structures
+== Graph & Tree Data Structures
 
 Graph-based data structures are everywhere whether you realize it or not. You can find them in databases, Web (HTML DOM tree), search algorithms, finding the best route to get home and many more uses. We are going to learn the basic concepts and when to choose one over the other.
 
 .In this chapter we are going to learn:
 - Exciting <<part03-graph-data-structures#graph>> data structure applications
 - Searching efficiently with a <<part03-graph-data-structures#tree>> data structures.
-- One of the most versatile data structure of all <<part03-graph-data-structures#hashmap>>.
-- Keeping dups out with a <<part03-graph-data-structures#set>>.
+- One of the most versatile data structure of all <<hashmap-chap>>.
+- Keeping duplicates out with a <<tree-set-chap>>.
 By the end of this section, you will know the data structures trade-offs and when to use one over the other.
 
 include::content/part03/tree-intro.asc[]
@@ -24,11 +24,17 @@ include::content/part03/binary-search-tree-traversal.asc[]
 // <<<
 // include::content/part03/map.asc[]
 
-<<
-include::content/part03/treemap.asc[]
+// <<<
+// include::content/part03/tree-map.asc[]
+
+// <<<
+// include::content/part02/hash-set.asc[]
+
+<<<
+include::content/part03/tree-map.asc[]
 
 <<<
-include::content/part03/set.asc[]
+include::content/part03/tree-set.asc[]
 
 <<<
 include::content/part03/graph.asc[]

book/part03-graph-data-structures.asc

@@ -1,7 +1,7 @@
 include::../../../book/content/part03/map.asc[]
 
 <<<
-include::../../../book/content/part03/hashmap.asc[]
+include::../../../book/content/part02/hash-map.asc[]
 
 <<<
-include::../../../book/content/part03/treemap.asc[]
+include::../../../book/content/part03/tree-map.asc[]

src/data-structures/maps/README.adoc

@@ -1 +1 @@
-include::../../../../book/content/part03/hashmap.asc[]
+include::../../../../book/content/part02/hash-map.asc[]

src/data-structures/maps/hash-maps/readme.asc

@@ -1 +1 @@
-include::../../../../book/content/part03/treemap.asc[]
+include::../../../../book/content/part03/tree-map.asc[]

src/data-structures/maps/tree-maps/readme.asc

@@ -1 +1 @@
-include::../../../book/content/part03/set.asc[]
+include::../../../book/content/part02/hash-set.asc[]