update indexes

amejiarosario · amejiarosario · commit a0f21a2fdee1 · 2019-03-26T18:51:33.000-04:00
diff --git a/book/chapters/array.adoc b/book/chapters/array.adoc
@@ -1,5 +1,6 @@
 = Array
-
+(((Array)))
+(((Data Structures, Linear, Array)))
 Arrays are one of the most used data structures. You probably have used it a lot but are you aware of the runtimes of  `splice`, `shift`  and other operations? In this chapter, we are going deeper into the most common operations and their runtimes.
 
 == Array  Basics
@@ -184,4 +185,5 @@ To sum up, the time complexity on an array is:
 ^|_Index/Key_ ^|_Value_ ^|_beginning_ ^|_middle_ ^|_end_ ^|_beginning_ ^|_middle_ ^|_end_
 | Array ^|O(1) ^|O(n) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(n) ^|O(1) ^|O(n)
 |===
-indexterm:[Runtime, Linear]
+(((Linear)))
+(((Runtime, Linear)))
diff --git a/book/chapters/big-o-examples.adoc b/book/chapters/big-o-examples.adoc
@@ -23,7 +23,8 @@ image:image5.png[CPU time needed vs. Algorithm runtime as the input size increas
 The above chart shows how the running time of an algorithm is related to the amount of work the CPU has to perform. As you can see O(1) and O(log n) are very scalable. However, O(n^2^) and worst can make your computer run for years [big]#😵# on large datasets. We are going to give some examples so you can identify each one.
 
 == Constant
-
+(((Constant)))
+(((Runtime, Constant)))
 Represented as *O(1)*, it means that regardless of the input size the number of operations executed is always the same. Let’s see an example.
 
 [#constant-example]
@@ -44,7 +45,8 @@ Another more real life example is adding an element to the begining of a <<Linke
 As you can see, in both examples (array and linked list) if the input is a collection of 10 elements or 10M it would take the same amount of time to execute. You can't get any more performance than this!
 
 == Logarithmic
-
+(((Logarithmic)))
+(((Runtime, Logarithmic)))
 Represented in Big O notation as *O(log n)*, when an algorithm has this running time it means that as the size of the input grows the number of operations grows very slowly. Logarithmic algorithms are very scalable. One example is the *binary search*.
 indexterm:[Runtime, Logarithmic]
 
@@ -65,7 +67,8 @@ This binary search implementation is a recursive algorithm, which means that the
 Finding the runtime of recursive algorithms is not very obvious sometimes. It requires some tools like recursion trees or the https://adrianmejia.com/blog/2018/04/24/analysis-of-recursive-algorithms/[Master Theorem]. The `binarySearch` divides the input in half each time. As a rule of thumb, when you have an algorithm that divides the data in half on each call you are most likely in front of a logarithmic runtime: _O(log n)_.
 
 == Linear
-
+(((Linear)))
+(((Runtime, Linear)))
 Linear algorithms are one of the most common runtimes. It’s represented as *O(n)*. Usually, an algorithm has a linear running time when it iterates over all the elements in the input.
 
 [#linear-example]
@@ -90,7 +93,8 @@ As we learned before, the big O cares about the worst-case scenario, where we wo
 Space complexity is also *O(n)* since we are using an auxiliary data structure.  We have a map that in the worst case (no duplicates) it will hold every word.
 
 == Linearithmic
-
+(((Linearithmic)))
+(((Runtime, Linearithmic)))
 An algorithm with a linearithmic runtime is represented as _O(n log n)_. This one is important because it is the best runtime for sorting! Let’s see the merge-sort.
 
 [#linearithmic-example]
@@ -125,8 +129,8 @@ image:image11.png[Mergesort visualization,width=500,height=600]
 How do we obtain the running time of the merge sort algorithm? The mergesort divides the array in half each time in the split phase, _log n_, and the merge function join each splits, _n_. The total work we have *O(n log n)*. There more formal ways to reach to this runtime like using the https://adrianmejia.com/blog/2018/04/24/analysis-of-recursive-algorithms/[Master Method] and https://www.cs.cornell.edu/courses/cs3110/2012sp/lectures/lec20-master/lec20.html[recursion trees].
 
 == Quadratic
-
-indexterm:[Runtime, Quadratic]
+(((Quadratic)))
+(((Runtime, Quadratic)))
 Running times that are quadratic, O(n^2^), are the ones to watch out for. They usually don’t scale well when they have a large amount of data to process.
 
 Usually, they have double-nested loops that where each one visits all or most elements in the input. One example of this is a naïve implementation to find duplicate words on an array.
@@ -149,7 +153,8 @@ As you can see, we have two nested loops causing the running time to be quadrati
 Let’s say you want to find a duplicated middle name in a phone directory book of a city of ~1 million people. If you use this quadratic solution you would have to wait for ~12 days to get an answer [big]#🐢#; while if you use the <<Linear, linear solution>> you will get the answer in seconds! [big]#🚀#
 
 == Cubic
-
+(((Cubic)))
+(((Runtime, Cubic)))
 Cubic *O(n^3^)* and higher polynomial functions usually involve many nested loops. As an example of a cubic algorithm is a multi-variable equation solver (using brute force):
 
 [#cubic-example]
@@ -174,7 +179,8 @@ WARNING: This just an example, there are better ways to solve multi-variable equ
 As you can see three nested loops usually translates to O(n^3^). If you have a four variable equation and four nested loops it would be O(n^4^) and so on when we have a runtime in the form of _O(n^c^)_, where _c > 1_, we can refer as a *polynomial runtime*.
 
 == Exponential
-
+(((Exponential)))
+(((Runtime, Exponential)))
 Exponential runtimes, O(2^n^), means that every time the input grows by one the number of operations doubles. Exponential programs are only usable for a tiny number of elements (<100) otherwise it might not finish on your lifetime.  [big]#💀#
 
 Let’s do an example.
@@ -203,7 +209,8 @@ include::{codedir}/runtimes/07-sub-sets.js[tag=snippet]
 Every time the input grows by one the resulting array doubles. That’s why it has an *O(2^n^)*.
 
 == Factorial
-
+(((Factorial)))
+(((Runtime, Factorial)))
 Factorial runtime, O(n!), is not scalable at all. Even with input sizes of ~10 elements, it will take a couple of seconds to compute. It’s that slow! [big]*🍯🐝*
 
 .Factorial
diff --git a/book/chapters/bubble-sort.adoc b/book/chapters/bubble-sort.adoc
@@ -7,6 +7,8 @@ Bubble sort is a simple sorting algorithm that "bubbles up" the biggest values t
 It's also called _sinking sort_ because the most significant values "sink" to the right side of the array.
 This algorithm is adaptive, which means that if the array is already sorted, it will take only _O(n)_ to "sort".
 However, if the array is entirely out of order, it will require _O(n^2^)_ to sort.
+(((Quadratic)))
+(((Runtime, Quadratic)))
 
 == Bubble Sort Implementation
 
diff --git a/book/chapters/chapter3.adoc b/book/chapters/chapter3.adoc
@@ -11,20 +11,25 @@ include::tree.adoc[]
 
 
 // (g)
+<<<
 include::tree--binary-search-tree.adoc[]
 
+<<<
 include::tree--search.adoc[]
 
+<<<
 include::tree--self-balancing-rotations.adoc[]
 
 :leveloffset: +1
 
+<<<
 include::tree--avl.adoc[]
 
 :leveloffset: -1
 
 // (g)
 // include::map.adoc[]
+<<<
 include::map-intro.adoc[]
 
 :leveloffset: +1
diff --git a/book/chapters/divide-and-conquer--fibonacci.adoc b/book/chapters/divide-and-conquer--fibonacci.adoc
@@ -52,7 +52,8 @@ graph G {
 ....
 
 In the diagram, we see the two recursive calls needed to compute each number. So if we follow the _O(branches^depth^)_ we get O(2^n^). [big]#🐢#
-
+(((Exponential)))
+(((Runtime, Exponential)))
 NOTE: Fibonacci is not a perfect binary tree since some nodes only have one child instead of two. The exact runtime for recursive Fibonacci is _O(1.6^n^)_ (still exponential time complexity).
 
 Exponential time complexity is pretty bad. Can we do better?
diff --git a/book/chapters/dynamic-programming--fibonacci.adoc b/book/chapters/dynamic-programming--fibonacci.adoc
@@ -23,7 +23,8 @@ graph G {
 ....
 
 This graph looks pretty linear now. It's runtime _O(n)_!
-indexterm:[Runtime, Linear]
+(((Linear)))
+(((Runtime, Linear)))
 
 (((Memoization)))
 TIP: Saving previous results for later is a technique called "memoization". This is very common to optimize recursive algorithms with overlapping subproblems. It can make exponential algorithms linear!
diff --git a/book/chapters/graph.adoc b/book/chapters/graph.adoc
@@ -1,5 +1,6 @@
 = Graph
-
+(((Graph)))
+(((Data Structures, Non-Linear, Graph)))
 Graphs are one of my favorite data structures.
 They have a lot of cool applications like optimizing routes, social network analysis to name a few. You are probably using apps that use graphs every day.
 First, let’s start with the basics.
diff --git a/book/chapters/insertion-sort.adoc b/book/chapters/insertion-sort.adoc
@@ -31,4 +31,6 @@ include::{codedir}/algorithms/sorting/insertion-sort.js[tag=sort, indent=0]
 - <<Adaptive>>: [big]#✅# Yes
 - Time Complexity: [big]#⛔️# <<Quadratic>> _O(n^2^)_
 - Space Complexity: [big]#✅# <<Constant>> _O(1)_
-indexterm:[Runtime, Quadratic]
+
+(((Quadratic)))
+(((Runtime, Quadratic)))
diff --git a/book/chapters/linked-list.adoc b/book/chapters/linked-list.adoc
@@ -1,5 +1,7 @@
 = Linked List
-
+(((Linked List)))
+(((List)))
+(((Data Structures, Linear, Linked List)))
 A list (or Linked List) is a linear data structure where each node is linked to another one.
 
 Linked Lists can be:
@@ -248,8 +250,9 @@ So far, we have seen two liner data structures with different use cases. Here’
 | Linked List (singly) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(n)* ^|O(n)
 | Linked List (doubly) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(1)* ^|O(n)
 |===
+(((Linear)))
+(((Runtime, Linear)))
 
-indexterm:[Runtime, Linear]
 If you compare the singly linked list vs. doubly linked list, you will notice that the main difference is deleting elements from the end. For a singly list is *O(n)*, while for a doubly list is *O(1)*.
 
 Comparing an array with a doubly linked list, both have different use cases:
diff --git a/book/chapters/map-hashmap-vs-treemap.adoc b/book/chapters/map-hashmap-vs-treemap.adoc
@@ -26,4 +26,7 @@ As we discussed so far, there are trade-off between the implementations
 |===
 {empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
 
-indexterm:[Runtime, Logarithmic]
+(((Linear)))
+(((Runtime, Linear)))
+(((Logarithmic)))
+(((Runtime, Logarithmic)))
diff --git a/book/chapters/map-hashmap.adoc b/book/chapters/map-hashmap.adoc
@@ -1,5 +1,7 @@
 = HashMap
-
+(((HashMap)))
+(((HashTable)))
+(((Data Structures, Non-Linear, HashMap)))
 A HashMap is a Map implementation. HashMaps are composed of two things:
 1) a hash function and
 2) a bucket array to store values.
diff --git a/book/chapters/map-intro.adoc b/book/chapters/map-intro.adoc
@@ -1,5 +1,6 @@
 = Map
-
+(((Map)))
+(((Data Structures, Non-Linear, Map)))
 A map is a data structure to store pairs of data: *key* and *value*. In an array, you can only store values. The array’s key is always the position index. However, in a *Map* the key can be whatever you want.
 
 IMPORTANT: Map is a data structure that _maps_ *keys* to *values*.
diff --git a/book/chapters/map-treemap.adoc b/book/chapters/map-treemap.adoc
@@ -1,5 +1,6 @@
 = TreeMap
-
+(((TreeMap)))
+(((Data Structures, Non-Linear, TreeMap)))
 A TreeMap is a Map implementation using Binary Search Trees.
 
 Implementing a Map with a tree, TreeMap, has a couple of advantages over a HashMap:
diff --git a/book/chapters/merge-sort.adoc b/book/chapters/merge-sort.adoc
@@ -50,3 +50,7 @@ Merge sort has an _O(n log n)_  running time. For more details about how to extr
 - Recursive: Yes
 - Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
 - Space Complexity: [big]#⚠️# <<Linear>> _O(n)_, use auxiliary memory
+
+(((Linearithmic)))
+(((Runtime, Linearithmic)))
+(((Space complexity, Linear)))
diff --git a/book/chapters/non-linear-data-structures-intro.adoc b/book/chapters/non-linear-data-structures-intro.adoc
@@ -1,6 +1,6 @@
 [partintro]
 --
-Non-Linear data structures are everywhere whether you realize it or not. They are used in databases, Web (HTML DOM tree), search algorithms, finding the best route to get home and so on. We are going to learn the basic concepts and when to choose one over the other.
+Non-Linear 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 <<Graph>> data structure applications
diff --git a/book/chapters/queue.adoc b/book/chapters/queue.adoc
@@ -1,5 +1,6 @@
 = Queue
-
+(((Queue)))
+(((Data Structures, Linear, Queue)))
 A queue is a linear data structure where the data flows in a *First-In-First-Out* (FIFO) manner.
 
 .Queue data structure is like a line of people: the First-in, is the First-out
diff --git a/book/chapters/quick-sort.adoc b/book/chapters/quick-sort.adoc
@@ -77,8 +77,11 @@ With the optimization, Quicksort has an _O(n log n)_ running time. Similar to th
 - <<Online>>: [big]#️❌# No, the pivot element can be choose at random.
 - Recursive: Yes
 - Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
-- Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
-indexterm:[Space Complexity, Linear]
+- Space Complexity: [big]#✅# <<Constant>> _O(1)_
+
+(((Linearithmic)))
+(((Runtime, Linearithmic)))
+(((Space complexity, Constant)))
 
 // Resources:
 // https://www.khanacademy.org/computing/computer-science/algorithms/quick-sort/a/linear-time-partitioning
diff --git a/book/chapters/selection-sort.adoc b/book/chapters/selection-sort.adoc
@@ -51,4 +51,5 @@ There you have it, `2b` now comes before `2a`.
 
 // CAUTION: In practice, selection sort performance is the worst compared <<Bubble Sort>> and <<Insertion Sort>>. The only advantage of selection sort is that it minimizes the number of swaps. In case, that swapping is expensive, then it could make sense to use this one over the others.
 
-indexterm:[Runtime, Quadratic]
+(((Quadratic)))
+(((Runtime, Quadratic)))
diff --git a/book/chapters/set.adoc b/book/chapters/set.adoc
@@ -1,5 +1,6 @@
 = Set
-
+(((Set)))
+(((Data Structures, Non-Linear, Set)))
 A set is a data structure where duplicated entries are not allowed. Set is like an array with unique values.
 
 NOTE: JavaScript has already a built-in Set data structure.
@@ -212,6 +213,8 @@ rehash happens, it will take *O(n)* instead of *O(1)*. A `TreeSet` is always *O(
 {empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
 
 indexterm:[Runtime, Linear]
+(((Logarithmic)))
+(((Runtime, Logarithmic)))
 To recap, HashSet and TreeSet will keep data without duplicates. The
 difference besides runtime is that:
 
diff --git a/book/chapters/stack.adoc b/book/chapters/stack.adoc
@@ -1,5 +1,6 @@
 = Stack
-
+(((Stack)))
+(((Data Structures, Linear, Stack)))
 The stack is a data structure that restricts the way you add and remove data. It only allows you to insert and retrieve in a *Last-In-First-Out* (LIFO) fashion.
 
 An analogy is to think the stack is a rod and the data are discs. You can only take out the last one you put in.
diff --git a/book/chapters/tree--avl.adoc b/book/chapters/tree--avl.adoc
@@ -1,22 +1,23 @@
 = AVL Tree
-
+(((AVL Tree)))
+(((Tree, AVL)))
 AVL Tree is named after their inventors (**A**delson-**V**elsky and **L**andis).
-This self-balancing tree keep track of subtree sizes to know if a rebalance is needed or not.
+This self-balancing tree keeps track of subtree sizes to know if a rebalance is needed or not.
 We can compare the size of the left and right subtrees using a balance factor.
 
 [NOTE]
 ====
 
-The *balanced factor* on each node is calculated recurviely as follows:
+The *balanced factor* on each node is calculated recursively as follows:
 
 ----
 Balance Factor = (left subtree height) - (right subtree height)
 ----
 
 ====
 
-The implementation will got into the BST node.
-We will need two methods to calculate the left and right subtree, and with those we can get the balance factor.
+The implementation will go in the BST node class.
+We will need two methods to calculate the left and right subtree, and with those, we can get the balance factor.
 
 .Balance Factor methods on the BST node
 [source, javascript]
@@ -27,25 +28,25 @@ include::{codedir}/data-structures/trees/binary-tree-node.js[tag=avl, indent=0]
 
 == Implementing AVL Tree
 
-Implementing an AVL Tree is not too hard, since it builds upon what we did in the Binary Search Tree.
+Implementing an AVL Tree is not too hard since it builds upon what we did in the Binary Search Tree.
 
 .AVL Tree class
 [source, javascript]
 ----
 include::{codedir}/data-structures/trees/avl-tree.js[tag=AvlTree]
 ----
 
-As you can see, AVL tree inherits from the BST class.
-The insert and remove operations works the same as in the BST, except that at the end we call `balanceUptream`.
-This function makes balance the tree after every change if is needed. Let's see how it's implemented.
+As you can see, the AVL tree inherits from the BST class.
+The insert and remove operations work the same as in the BST, except that at the end we call `balanceUpstream`.
+This function checks if the tree is symmetrical after every change to the tree. If the tree went out of balance, it would execute the appropriated rotation to fix it.
 
 .Balance Upstream for AVL tree
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/avl-tree.js[tag=balanceUptream]
+include::{codedir}/data-structures/trees/avl-tree.js[tag=balanceUpstream]
 ----
 
-This function recurively goes from the modified node to the root checking if each node in between is balanced.
+This function recursively goes from the modified node to the root checking if each node in between is balanced.
 Now, let's examine how does the balancing works on AVL tree.
 
 .Balance method for AVL tree
diff --git a/book/chapters/tree--binary-search-tree.adoc b/book/chapters/tree--binary-search-tree.adoc
diff --git a/book/chapters/tree--binary-tree-traversal.adoc b/book/chapters/tree--binary-tree-traversal.adoc
diff --git a/book/chapters/tree--search.adoc b/book/chapters/tree--search.adoc
diff --git a/book/chapters/tree--self-balancing-rotations.adoc b/book/chapters/tree--self-balancing-rotations.adoc
diff --git a/book/chapters/tree.adoc b/book/chapters/tree.adoc
diff --git a/src/data-structures/trees/avl-tree.js b/src/data-structures/trees/avl-tree.js

-Original file line number
+Diff line change
@@ @@ -1,10 +1,12 @@ @@
 = Binary Search Tree
+-
 -.The Binary Search Tree (BST) is a tree data structure that keeps the following constraints:
 +(((Binary Search Tree)))
 +(((BST)))
 +(((Data Structures, Non-Linear, 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".
 * All trees must a have a "root" node.
 -* The order of nodes values must be: left child < parent < right child.
 -* Nodes might need re-ordering after each insert/delete operation to keep the `left < parent < right` constraint.
 +* The order of nodes values must be: `left child < parent < right child`.
 +* Nodes might need re-ordering after each insert/delete operation to keep the `left <= parent < right` constraint.
 == Implementing a Binary Search Tree
 === Inserting new elements in a BST
 .For inserting an element, in a BST, we have two scenarios:
 -1.  If the tree is empty (root element is null), we add the newly created node as root, and we are done!
 -2.  If the root is not null. Start from the root, then compare the node’s value against the new element. If the node has higher than a new item, we move to the right child, otherwise to the left. We check each node recursively until we find an empty spot where we can put the new element and keep the rule `right < parent < left`.
 +1.  If the tree is empty (root element is null), we add the newly created node as root, and that's it!
 +2.  If the root is not null. Start from it and compare the node’s value against the new element. If the node has higher than a new item, we move to the right child, otherwise to the left. We check each node recursively until we find an empty spot where we can put the new element and keep the rule `right < parent < left`.
 .  If we insert the same value multiple times, we don’t want duplicates. So, we can keep track of multiples using a duplicity counter.
 For instance, let’s say that we want to insert the values 19, 21, 10, 2, 8 in a BST:
 ==== Removing a leaf (Node with 0 children)
 -Deleting a leaf is the easiest, we look for their parent and set the child to null.
 +Deleting a leaf is the easiest; we look for their parent and set the child to null.
 .Removing node without children from a BST.
 image:image37.png[image,width=528,height=200]
 image:image39.png[image,width=528,height=404]
 -In the example, we delete the root node 19. This leaves the two orphans (node 10 and node 21). There are no more parents because node 19 was the *root* element. One way to solve this problem is to *combine* the left subtree (Node 10 and descendants) into the right subtree (node 21). The final result is node 21 is the new root.
 +In the example, we delete the root node 19. This deletion leaves two orphans (node 10 and node 21). There are no more parents because node 19 was the *root* element. One way to solve this problem is to *combine* the left subtree (Node 10 and descendants) into the right subtree (node 21). The final result is node 21 is the new root.
 What would happen if node 21 had a left child (e.g., node 20)? Well, we would move node 10 and its descendants' bellow node 20.
 <1> Try to find if the value exists on the tree.
 <2> If the value doesn’t exist we are done!
 <3> Create new subtree without the value to delete
 -<4> Check the multiplicity (duplicates) and decrement the count in case we have multiple nodes with the same value
 +<4> Check the multiplicity (duplicates) and decrement the count if we have multiple nodes with the same value
 <5> If the `nodeToRemove` was the root, then we move the removed node’s children as the new root.
 <6> If it was not the root, then we go to the deleted node’s parent and put their children there.
-Original file line number
+Diff line change
@@ @@ -1,10 +1,11 @@ @@
 = Binary Tree Traversal
+-
 -As mentioned before, there are different ways to visit all the nodes or search for a value in a binary tree. On this section we are going to focus on depth-first tree traversal. The implementations are recursive since it's more elegant and concise. Let's explore them.
 +(((Binary Tree Traversal)))
 +As mentioned before, there are different ways to visit all the nodes or search for a value in a binary tree. On this section, we are going to focus on depth-first tree traversal.
 == In Order Traversal
+-
 -If you tree happens to be a binary search tree (BST), then could use "in order" traversal to get the values sorted in ascending order. To accomplish this, you have to visit the nodes in a `left-root-right` order.
 +(((Tree Traversal, In Order)))
 +(((In Order Traversal)))
 +If your tree happens to be a binary search tree (BST), then you can use "in order" traversal to get the values sorted in ascending order. To accomplish this, you have to visit the nodes in a `left-root-right` order.
 If we have the following tree:
 ----
 include::{codedir}/data-structures/trees/binary-search-tree.js[tag=inOrderTraversal, indent=0]
 ----
 -This function goes recursively to the leftmost element and then yield that node, then we go to the right child (if any) and repeat the process. This will get us the values ordered.
 +This function goes recursively to the leftmost element and then yield that node, then we go to the right child (if any) and repeat the process. This method will get us the values ordered.
 == Pre Order Traversal
+-
 -Pre-order traveral visits nodes in this order `root-left-right` recursively.
 +(((Tree Traversal, Pre Order)))
 +(((Pre Order Traversal)))
 +Pre-order traversal visits nodes in this order `root-left-right` recursively.
 .Usage of pre-order traversal:
 - Create a copy of the tree.
 Pre-order traverval will return `10, 5, 4, 3, 30, 15, 40`.
 == Post-order Traversal
 +(((Tree Traversal, Post Order)))
 +(((Post Order Traversal)))
 +Post-order traversal goes to each node in this order `left-right-root` recursively.
 -Post-order traveral goes to each node in this order `left-right-root` recursively.
+-
 -.Usages of the post-order tree traveral
 +.Usages of the post-order tree traversal
 - Traversal is used to delete the tree because you visit the children before removing the parent.
 - Get the postfix expression of an expression tree used in the http://en.wikipedia.org/wiki/Reverse_Polish_notation[reverse polish notation].
-Original file line number
+Diff line change
@@ @@ -1,7 +1,7 @@ @@
 = Tree Search & Traversal
 So far we covered, how to insert/delete/search values in a binary search tree (BST).
 -However, not all binary trees are BST, so there are other ways to look for values or visit all nodes in a certain order.
 +However, not all binary trees are BST, so there are other ways to look for values or visit all nodes in a particular order.
 If we have the following tree:
 ----
 ----
 Depending on what traversal methods we used we will have a different visiting order.
+-
 +(((Tree Traversal)))
 +(((Tree, Traversal)))
 .Tree traversal methods
 - Breadth-first traversal (a.k.a level order traversal): `10, 5, 30, 4, 15, 40, 3`
 - Depth-first traversal
 ** In-order (left-root-right): `3, 4, 5, 10, 15, 30, 40`
 ** Pre-order (root-left-right): `10, 5, 4, 3, 30, 15, 40`
 ** Post-order (left-right-root): `3, 4, 5, 15, 40, 30, 10`
 -Why do we care? Well, there are certain problems that you solve more optimally using one or another traversal method. For instance to get the size of a subtree, finding maximums/minimums, and so on.
 +Why do we care? Well, there are specific problems that you can solve more optimally using one or another traversal method. For instance to get the size of a subtree, finding maximums/minimums, and so on.
 -Let's cover Breadth-first search (BFS) and Depth-first search (DFS).
 +Let's cover the Breadth-first search (BFS) and Depth-first search (DFS).
 [Breadth First Search]
 == Breadth-First Search for Binary Tree
+-
 -Breadth-first search goeas wide (breadth) before going deep. Hence, the name. In other words, it goes level by level. It visits all the inmediate nodes or children and then move on to the children's children.
 +(((BFS)))
 +(((Breadth-First Search)))
 +(((Tree, Breadth-First Search)))
 +The breadth-first search goes wide (breadth) before going deep. Hence, the name. In other words, it goes level by level. It visits all the immediate nodes or children and then moves on to the children's children.
 Let's how can we implement it!
 .Breath-First Search (BFS) Implementation
 As you see, the BFS uses a <<Queue>> data structure. We enqueue all the children of the current node and then dequeue them as we visit them.
 -Note the asterisk (`*`) in front of the function means that this function is a generator that yield values.
 +Note the asterisk (`*`) in front of the function means that this function is a generator that yields values.
 +(((JavaScript Notes, Generators)))
 +(((Generators)))
 .JavaScript Generators
 ****
 -JavaScript generators were added as part of ES6, they allow process possibly expensive operations one by one. You can convert any function into a generator by adding the asterisk in front and `yield`ing a value.
 +JavaScript generators were added as part of ES6; they allow process possibly expensive operations one by one. You can convert any function into a generator by adding the asterisk in front and `yield`ing a value.
 Then you can use `next()` to get the value and also `done` to know if it's the last value. Here are some examples:
 == Depth-First Search for Binary Tree
+-
 -Depth-First search goes deep before going wide. It means, that starting for the root it goes as deep as it can until it found a leaf node (node without children), then it visits all the remaing nodes that were in the path.
 +(((DFS)))
 +(((Depth-First Search)))
 +(((Tree, Depth-First Search)))
 +Depth-First search goes deep (depth) before going wide. It means that starting for the root it goes as deep as it can until it found a leaf node (node without children), then it visits all the remaining nodes that were in the path.
 .Depth-First Search (DFS) Implementation with a Stack
 [source, javascript]
 ----
 include::{codedir}/data-structures/trees/binary-search-tree.js[tag=dfs,indent=0]
 ----
 -This is a iterative implementation of a DFS using an <<Stack>>.
 -It's almost identical to the BFS but instead of using a <<Queue>> we usa a Stack.
 +This is an iterative implementation of a DFS using an <<Stack>>.
 +It's almost identical to the BFS, but instead of using a <<Queue>> we use a Stack.
 We can also implement it as recursive functions are we are going to see in the <<Binary Tree Traversal>> section.
 == Depth-First Search vs. Breadth-First Search
 -We can see visually the difference on how the DFS and BFS search for nodes:
 +We can see visually the difference between how the DFS and BFS search for nodes:
 .Depth-First Search vs. Breadth-First Search
 image:depth-first-search-dfs-breadth-first-search-bfs.jpg[]
 -As you can see the DFS in two iterations is already at one of the farthest node from the root while BFS search nearby nodes first.
 +As you can see the DFS in two iterations is already at one of the farthest nodes from the root while BFS search nearby nodes first.
 .Use DFS when:
 - The node you are looking for is likely to be *far* from the root.
 - The node you are looking for is *nearby* the root.
 :leveloffset: +1
+-
 +<<<
 include::tree--binary-tree-traversal.adoc[]
 :leveloffset: -1
+-
+-
+-
+-
+-
+-
+-
-Original file line number
+Diff line change
@@ @@ -1,11 +1,11 @@ @@
 = Self-balancing Binary Search Trees
 -Binary Search Trees (BST) are a great data structure to find elements very fast _O(n log n)_.
 -However, when the BST branches has different branch sizes then the performance suffers.
 -In the worst case, all nodes can go to one side (e.g. right) and then the search time would be linear.
 +Binary Search Trees (BST) are an excellent data structure to find elements very fast _O(log n)_.
 +However, when the BST branches have different branch sizes, then the performance suffers.
 +In the worst case, all nodes can go to one side (e.g., right) and then the search time would be linear.
 At this point searching element won't be any better on that tree than an array or linked list. Yikes!
 -Self-balanced trees will automatically balanced the tree when an element is inserted to keep search performace.
 +Self-balanced trees will automatically rebalance the tree when an element is inserted to keep search performance.
 We balance a tree by making the height (distance from a node to the root) of any leaf on the tree as similar as possible.
 .From unbalanced BST to balanced BST
 Let's examine all the possible rotation we can do to balance a tree.
 == Tree Rotations
+-
 +(((Tree Rotations)))
 We can do single rotations left and right and also we can do double rotations.
 Let's go one by one.
 === Single Right Rotation
 -Right rotation moves a node on the right as a child of other node.
 +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`.
 We want to balance the tree, for that we need to do a right rotation of node 3.
 -So, the node 3 is moved as the right child of the previous child.
 +So, we move node 3 as the right child of the previous child.
 .Single right rotation implementation
 [source, javascript]
 The `swapParentChild` as it name says, swap the children.
 For our example, it swaps `node 4`'s left children from `node 3` to `node 2`.
 -Take a look at the implementation
 +Take a look at the implementation.
 .Swap Parent and Child Implementation
 [source, javascript]
 Still not quite what we want.
 So, `newParent.setRightAndUpdateParent(node)` will make `node 3` the right child of `node 2`.
 -Finally, we remove left child of `node 3` to be `null`.
 +Finally, we remove the left child of `node 3` to be `null`.
 ----
 include::{codedir}/data-structures/trees/binary-tree-node.js[tag=setAndUpdateParent]
 ----
 -You can also checkout the full
 +You can also check out the full
 https://github.com/amejiarosario/dsa.js/blob/adfd8a660bbe0a7068fd7881aff9f51bdb9f92ae/src/data-structures/trees/binary-tree-node.js#L9[binary tree node implementation].
 === Left Right Rotation
 include::{codedir}/data-structures/trees/tree-rotations.js[tag=leftRightRotation]
 ----
 -As you can see we do a left and then a right rotation. This is also called `LR rotation`
 +As you can see we do a left and then a right rotation. This rotation is also known as `LR rotation`
 === Right Left Rotation
 include::{codedir}/data-structures/trees/tree-rotations.js[tag=rightLeftRotation]
 ----
 -This rotation is also refered as `RL rotation`.
 +This rotation is also referred to as `RL rotation`.
 == Self-balancing trees implementations
-Original file line number
+Diff line change
@@ @@ -1,5 +1,6 @@ @@
 = Tree
+-
 +(((Tree)))
 +(((Data Structures, Non-Linear, Tree)))
 A tree is a non-linear data structure where a node can have zero or more connections. The topmost node in a tree is called *root*. The linked nodes to the root are called *children* or *descendants*.
 .Tree Data Structure: root node and descendants.
 There are different kinds of trees depending on the restrictions. E.g. The trees that have two children or less are called *binary tree*, while trees with at most three children are called *Ternary Tree*. Since binary trees are most common we are going to cover them here and others in another chapter.
 === Binary Tree
+-
 +(((Binary Tree)))
 +(((Data Structures, Non-Linear, Binary Tree)))
 The binary restricts the nodes to have at most two children. Trees, in general, can have 3, 4, 23 or more, but not binary trees.
 .Binary tree has at most 2 children while non-binary trees can have more.
 image:image32.png[image,width=321,height=193]
 -Binary trees are the one of the most common types and it's used to build other data structures and applications.
 +Binary trees are one of the most used kinds of tree, and they are used to build other data structures.
 .Binary Tree Applications
 - <<Map>>
 === Binary Search Tree (BST)
+-
 +(((Binary Search Tree)))
 +(((Data Structures, Non-Linear, Binary Search Tree)))
 The Binary Search Tree (BST) is a specialization of the binary tree. BST has the same restriction as a binary tree; each node has at most two children. However, there’s another restriction: the values are ordered. It means the left child’s value has to be less or equal than the parent. In turn, the right child’s value has to be bigger than the parent.
 > BST: left ≤ parent < right
 === Binary Heap
+-
 +(((Binary Heap)))
 +(((Heap)))
 +(((Max-Heap)))
 +(((Min-Heap)))
 +(((Data Structures, Non-Linear, Binary Heap)))
 The heap (max-heap) is a type of binary tree where the children's values are higher than the parent. Opposed to the BST, the left child doesn’t have to be smaller than the right child.
 .Heap vs BST
 image:image34.png[image,width=325,height=176]
+-
 The (max) heap has the maximum value in the root, while BST doesn’t.
 -There is two kind of heaps: min-heap and max-heap.
 +There are two kinds of heaps: min-heap and max-heap.
 For a *max-heap*, the root has the highest value. The heap guarantee that as you move away from the root, the values get smaller. The opposite is true for a *min-heap*. In a min-heap, the lowest value is at the root, and as you go down the lower to the descendants, they will keep increasing values.
 .Max-heap keeps the highest value at the top while min-heap keep the lowest at the root.
-Original file line number
+Diff line change
+}
 // end::balance[]
 -// tag::balanceUptream[]
 +// tag::balanceUpstream[]
 /**
  * Bubbles up balancing nodes a their parents
+ *
  * @param {TreeNode} node
  */
 -function balanceUptream(node) {
 +function balanceUpstream(node) {
   let current = node;
   let newParent;
   while (current) {
+  }
   return newParent;
+}
 -// end::balanceUptream[]
 +// end::balanceUpstream[]
 // tag::AvlTree[]
 /**
    */
   add(value) {
     const node = super.add(value);
 -    this.root = balanceUptream(node);
 +    this.root = balanceUpstream(node);
     return node;
+  }
     const node = super.find(value);
     if (node) {
       const found = super.remove(value);
 -      this.root = balanceUptream(node.parent);
 +      this.root = balanceUpstream(node.parent);
       return found;
+    }