improve first part

Author: amejiarosario

book/chapters/algorithmic-toolbox.adoc

@@ -3,28 +3,30 @@
 Have you ever given a programming problem and freeze without knowing where to start?
 Well, in this section we are going to give some tips, so you don't get stuck while coding.
 
-TIP: Don't start coding right away. First, solve the problem, then write the code.
+TIP: TL;DR: Don't start coding right away. First, solve the problem, then write the code. Make it work first, make it better later.
 
 .Steps to solve algorithmic problems
 . *Understand* the requirements. Reframe it in your own words.
 . Draw a *simple example* (no edge cases yet)
-. Brainstorm
+. *Brainstorm* possible solutions
 .. How would you solve this problem *manually*? (without a computer) Is there any formula or theorem you can use?
 .. Is there any heuristics (largest, smallest, best ratio) or can you spot a pattern to solve this problem using a <<Greedy Algorithms, greedy algorithm>>?
-.. Can you address the simple base case and generalize for other cases using a *recursive solution*?
+.. Can you address the simple base case and generalize for other cases using a *recursive solution*? Can you divide the problem in subproblems? Try <<Divide and Conquer>>.
 .. Do you have to generate multiple solutions or try different paths? Try <<Backtracking>>.
+.. List all the data structures that you know that might solve this problem.
 .. If anything else fails, how would you solve it the dumbest way possible (brute force). We can optimize it later.
-. Optimize the solution.
+. *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 <<HashMap>> 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?
-.. Do you have a bunch of overlapping problems? Try <<Dynamic Programming>>.
-.. Can you trade-off space for speed? Use a <<HashMap, Map>> to speed up results
-. Test your algorithm with multiple examples
-. *Code*, yes, now you can code.
+. *Write Code*, yes, now you can code.
 .. Modularize your code with functions (don't do it all in one giant function please 🙏)
-. Test your code.
+.. Comment down edge cases but don't address until the basic cases are working.
+. *Test* your code.
 .. Choose a typical input and test against your code.
-.. Brainstorm about edge cases (empty, null values, overflows,
-.. How would scale your code?
+.. Brainstorm about edge cases (empty, null values, overflows, largest supported inputs)
+.. How would scale your code beyond the current boundaries?
 
 These steps should get you going even with the toughest algorithmic problems.
 

book/chapters/algorithms-analysis-intro.adoc

@@ -1,4 +1,4 @@
 [partintro]
 --
-In this section we are going to cover the basics about algorithms analysis. Also, we are going to discuss eight of the most commmon runtimes of algorithms and provide a code example for each one.
+In this part, we are going to cover the basics of algorithms analysis. Also, we are going to discuss the most common runtimes of algorithms and provide a code example for each one.
 --

book/chapters/algorithms-analysis.adoc

@@ -13,7 +13,7 @@ But why stop with the running time?
 We could also compare the memory "used" by different algorithms, and we called that *space complexity*.
 
 .In this chapter you will learn:
--    What’s the best way to measure your code performance.
+-    What’s the best way to measure the performance of your code regardless of what hardware you use.
 -    Learn how to use Big O notation to compare algorithms.
 -    How to use algorithms analysis to improve your programs speed.
 
@@ -24,15 +24,17 @@ Before going deeper, into space and time complexity, let's cover the basics real
 Algorithms (as you might know) are steps of how to do some task. When you cook, you follow a recipe (or an algorithm) to prepare a dish. Let's say you want to make a pizza.
 
 .Example of an algorithm
-// [source, js] // undefined functions
+[source, javascript]
 ----
-function bakePizza(dough, toppins = ['cheese']) {
-    const heatedOven = heatOvenTo(550);
-    punchDown(dough);
-    rollOut(dough);
-    applyToppings(dough, toppings);
-    const pizza = heatedOven.bakePizza(dough)
-    return pizza;
+import { punchDown, rollOut, applyToppings, Oven } from '../pizza-utils';
+
+function makePizza(dough, toppins = ['cheese']) {
+    const oven = new Oven(450);
+    const punchedDough = punchDown(dough);
+    const rolledDough = rollOut(punchedDough);
+    const rawPizza = applyToppings(rolledDough, toppings);
+    const pizzaPromise = oven.bake(rawPizza, { minutes: 20 });
+    return pizzaPromise;
 }
 ----
 
@@ -44,8 +46,6 @@ TIP: Algorithms are instructions on how to perform a task.
 
 Not all algorithms are created equal. There are “good” and “bad” algorithms. The good ones are fast; the bad ones are slow. Slow algorithms cost more money to run. Inefficient algorithms could make some calculations impossible in our lifespan!
 
-Most algorithms are affected by the size of the input. Let's say you need to arrange numbers in ascending order. Sorting ten digits will naturally take much less time than sorting 2 million of them.
-
 To give you a clearer picture of how different algorithms perform as the input size grows, take a look at the following table.
 
 .Relationship between algorithm input size and time taken to complete
@@ -59,8 +59,9 @@ To give you a clearer picture of how different algorithms perform as the input s
 |Find all permutations of a string |4 sec. |> vigintillion years |> centillion years |∞ |∞
 |=============================================================================================
 
-indexterm:(((Permutations)))
-However, if you keep the input size constant, you can notice the difference between an efficient algorithm and a slow one. An excellent sorting algorithm is `mergesort` for instance, and inefficient algorithm for large inputs is `bubble sort` .
+Most algorithms are affected by the size of the input (`n`). Let's say you need to arrange numbers in ascending order. Sorting ten digits will naturally take much less time than sorting out 2 million. But, how much longer? Some algorithms as the input size grow they take proportionally more time, we classify them as <<Linear, linear>> runtime [or `O(n)`]. Others might take power two longer; we call them <<Quadratic, quadratic>> running time [or `O(n^2^)`].
+
+If you keep the input size the same, and run diffferent algorithms implementations you would notice the difference between an efficient algorithm and a slow one. An excellent sorting algorithm is `mergesort` for instance, and inefficient algorithm for large inputs is `bubble sort` .
 Organizing 1 million elements with merge sort takes 20 seconds while bubble sort takes 12 days, ouch!
 The amazing thing is that both programs are measured on the same hardware with the same data!
 

book/chapters/array.adoc

@@ -1,11 +1,13 @@
 = 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.
+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`, `indexOf`  and other operations? In this chapter, we are going deeper into the most common operations and their runtimes.
 
 == Array  Basics
 
-An array is a collection of things (strings, characters, numbers, objects, etc.). They can be many or zero. Strings are a collection of Unicode characters and most of the array concepts apply to them.
+An array is a collection of things (strings, characters, numbers, objects, etc.). They can be many or zero.
+
+TIP: Strings are a collection of Unicode characters and most of the array concepts apply to them.
 
 .Fixed vs. Dynamic Size Arrays
 ****
@@ -34,7 +36,7 @@ const array0 = [];
 array0[2] = 1;
 ----
 
-Using the index, you can replace whatever value you want.
+Using the index, you can replace whatever value you want. The runtime is constant: _O(1)_.
 
 === Inserting at the beginning of the array
 
@@ -43,14 +45,18 @@ What if you want to insert a new element at the beginning of the array? You woul
 .Insert to head
 [source, javascript]
 ----
-array.unshift(0); //=> [0, 2, 5, 1, 9, 6, 7]
+const array = [2, 5, 1, 9, 6, 7];
+array.unshift(0); // ↪️ 8
+// array: [0, 2, 5, 1, 9, 6, 7]
 ----
 
 As you can see, `2` was the index 0, now was pushed to index 1, and everything else was moved one place. `unshift` takes *O(n)* since it affects all the elements in the array.
 
 .JavaScript built-in `array.unshift`
 ****
-The `unshift()` method adds one or more elements to the beginning of an array and returns the new length of the array. Runtime: O(n).
+The `unshift()` method adds one or more elements to the beginning of an array and returns the new length of the array.
+
+Runtime: O(n).
 ****
 
 === Inserting at the middle of the array
@@ -60,15 +66,19 @@ Inserting a new element in the middle involves moving part of the array but not
 .Inserting element in the middle
 [source, javascript]
 ----
-array.splice(1, 0, 111); // <1>
+const array = [2, 5, 1, 9, 6, 7];
+array.splice(1, 0, 111); // ↪️ [] <1>
+// array: [2, 111, 5, 1, 9, 6, 7]
 ----
-<1> at the position 1, delete 0 elements and insert 111. The array would be `[2, 111, 5, 1, 9, 6, 7]`
+<1> at the position `1`, delete `0` elements and insert `111`.
 
 The Big O for this operation would be *O(n)* since in worst case it would move most of the elements to the right.
 
 .JavaScript built-in `array.splice`
 ****
-The `splice()` method changes the contents of an array by removing existing elements and/or adding new elements. Runtime: O(n).
+The `splice()` method changes the contents of an array by removing existing elements and/or adding new elements.  Returns an array containing the deleted elements.
+
+Runtime: O(n).
 ****
 
 === Inserting at the end of the array
@@ -79,15 +89,18 @@ We can push new values to the end of the array like this:
 [source, javascript]
 ----
 const array = [2, 5, 1, 9, 6, 7];
-array.push(4); // <1>
+array.push(4); // ↪️ 7 <1>
+// array: [2, 5, 1, 9, 6, 7, 4]
 ----
-<1> The `4` element would be pushed to the end `[2, 5, 1, 9, 6, 7, 4]`.
+<1> The `4` element would be pushed to the end of the array. Notice that `push` returns the new length of the array.
 
 Adding to the tail of the array doesn’t change other indexes. E.g., element 2 is still at index 0. So, this is a constant time operation *O(1)*.
 
 .JavaScript built-in `array.push`
 ****
-The `push()` method adds one or more elements to the end of an array and returns the new length of the array. Runtime: O(1).
+The `push()` method adds one or more elements to the end of an array and returns the new length of the array.
+
+Runtime: O(1).
 ****
 
 == Searching by value and index
@@ -98,7 +111,7 @@ Searching by index is very easy using the `[]` operator:
 [source, javascript]
 ----
 const array = [2, 5, 1, 9, 6, 7];
-array[4]; //↪️ 6
+array[4]; // ↪️ 6
 ----
 
 Searching by index takes a constant time, *O(1)*, to retrieve values out of the array. If we want to get fancier we can create a function:
@@ -111,7 +124,7 @@ Searching by index takes a constant time, *O(1)*, to retrieve values out of the
 include::{codedir}/data-structures/arrays/array.js[tag=searchByIndex]
 ----
 
-Finding out if an element is in the array or not is a different story.
+Finding out if a value is in the array or not is a different story.
 
 // image:image18.png[image,width=528,height=338]
 
@@ -129,32 +142,40 @@ Deleting (similar to insertion) there are three possible scenarios, removing at
 
 === Deleting element from the beginning
 
-Deleting from the beginning can be done using the `splice` function and also the `shift`. Let’s use the `shift` since it’s simpler.
+Deleting from the beginning can be done using the `splice` function and also the `shift`. For simplicity, we will use the latter.
 
 .Deleting from the beginning of the array.
 [source, javascript]
 ----
-array.shift(); //=> [5, 1, 9, 6, 7]
+const array = [2, 111, 5, 1, 9, 6, 7];
+// Deleting from the beginning of the array.
+array.shift(); // ↪️2
+array.shift(); // ↪️111
+// array: [5, 1, 9, 6, 7]
 ----
 
-As expected, this will make every index to change, so this takes *O(n)*.
+As expected, this will change every index, so this takes *O(n)*.
 
 .JavaScript built-in array.shift
 ****
-The `shift()` method removes the first element from an array and returns that removed element. This method changes the length of the array. Runtime: O(n).
-****
+The `shift()` method shift all elements to the left. In turn, it removes the first element from an array and returns that removed element. This method changes the length of the array.
 
+Runtime: O(n).
+****
 
 === Deleting element from the middle
 
-We can use the splice operator for this.
+We can use the `splice` method for deleting an item from the middle of an array.
 
 .Deleting from the middle
 [source, javascript]
 ----
-array.splice(2, 1); // delete 1 element at position 2
-// => array: [2, 5, 9, 6, 7]
+const array = [0, 1, 2, 3, 4];
+// Deleting from the middle
+array.splice(2, 1); // ↪️[2] <1>
+// array: [0, 1, 3, 4]
 ----
+<1> delete 1 element at position 2
 
 Deleting from the middle might cause most the elements of the array to move back one position to fill in for the eliminated item. Thus, runtime: O(n).
 
@@ -165,25 +186,41 @@ Removing the last element is very straightforward:
 .Deleting last element from the array
 [source, javascript]
 ----
-array.pop(); // => array: [2, 5, 1, 9, 6]
+const array = [2, 5, 1, 9, 111];
+array.pop();  // ↪️111
+// array: [2, 5, 1, 9, 111]
 ----
 
 No element other element has been shifted, so it’s an _O(1)_ runtime.
 
 .JavaScript built-in `array.pop`
 ****
-The `pop()` method removes the last element from an array and returns that element. This method changes the length of the array. Runtime: O(1).
+The `pop()` method removes the last element from an array and returns that element. This method changes the length of the array.
+
+Runtime: O(1).
 ****
 
 == Array Complexity
 
 To sum up, the time complexity on an array is:
 
-.Time complexity for the array operations
+.Time/Space complexity for the array operations
 |===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
+.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space
 ^|_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)
 |===
 (((Linear)))
 (((Runtime, Linear)))
+(((Constant)))
+(((Runtime, Constant)))
+
+Array Operations
+|===
+| Operation | Time Complexity | Usage
+| push ^| O(1) | Insert element to the right side.
+| pop ^| O(1) | Remove the rightmost element.
+| unshift ^| O(n) | Insert element to the left side.
+| shift ^| O(n) | Remove leftmost element.
+| splice ^| O(n) | Insert and remove from anywhere.
+|===

book/chapters/chapter2.adoc

@@ -10,15 +10,19 @@ include::linear-data-structures-intro.adoc[]
 include::array.adoc[]
 
 //  (g)
+<<<
 include::linked-list.adoc[]
 
 //  (g)
+<<<
 include::stack.adoc[]
 
 // (g)
+<<<
 include::queue.adoc[]
 
 // (g)
+<<<
 include::linear-data-structures-outro.adoc[]
 
 :leveloffset: -1

book/chapters/chapter3.adoc

@@ -59,6 +59,6 @@ include::graph-search.adoc[]
 // Graph summary
 = Summary
 
-In this section, we learned about Graphs applications, properties and how we can implement them. We mention that you can represent a graph as a matrix or as a list of adjacencies. We went for implementing the later since it's more space efficient. We cover the basic graph operations like adding and removing nodes and edges.  In the algorithms section, we are going to cover searching values in the graph.
+In this section, we learned about Graphs applications, properties and how we can create them. We mention that you can represent a graph as a matrix or as a list of adjacencies. We went for implementing the later since it's more space efficient. We cover the basic graph operations like adding and removing nodes and edges.  In the algorithms section, we are going to cover searching values in the graph.
 
 :leveloffset: -1

book/chapters/linear-data-structures-intro.adoc

@@ -1,14 +1,16 @@
 [partintro]
 --
-Data Structures comes in many flavors. There’s no one to rule them all. There are tradeoffs for each one of them. Even thought in your day-to-day, you might not need to re-implementing them, knowing how they work internally would help you choose the right tool for the job. We are going to explore the most common data structures time and space complexity.
+Data Structures comes in many flavors. There’s no one to rule them all. You have to know the tradeoffs so you can choose the right one for the job.
+
+Even though in your day-to-day, you might not need to re-implementing them, knowing how they work internally would help you how when to use over the other or even tweak them to create a new one. We are going to explore the most common data structures time and space complexity.
 
 .In this part we are going to learn about the following linear data structures:
--	Array
--	Linked List
--	Stack
--	Queue
+- <<Array>>
+- <<Linked List>>
+- <<Stack>>
+- <<Queue>>
 
-Later, in the next part we are going to explore non-linear data structures like Graphs and Trees.
+Later, in the next part, we are going to explore non-linear data structures like <<Graph, Graphs>> and <<Tree, Trees>>.
 
 ifdef::backend-html5[]
 If you want to have a general overview of each one, take a look at the following interactive diagram:

book/chapters/linear-data-structures-outro.adoc

@@ -1,9 +1,6 @@
-
 = Array vs. Linked List & Queue vs. Stack
 
-In this chapter, we explored the most used linear data structures such as Arrays, Linked Lists, Stacks and Queues. We implemented them and discussed the runtime of their operations.
-
-To sum up,
+In this part of the book, we explored the most used linear data structures such as Arrays, Linked Lists, Stacks and Queues. We implemented them and discussed the runtime of their operations.
 
 .Use Arrays when…
 * You need to access data in random order fast (using an index).
@@ -22,9 +19,9 @@ To sum up,
 * You need to access your data as last-in, first-out (LIFO).
 * You need to implement a <<Depth-First Search for Binary Tree, Depth-First Search>>
 
-.Time Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)
+.Time/Space Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)
 |===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
+.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space
 ^|_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)
 | <<Singly Linked List>> ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(n)* ^|O(n)

book/chapters/linked-list.adoc

@@ -2,48 +2,49 @@
 (((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.
+A list (or Linked List) is a linear data structure where each node is "linked" to the next.
 
-Linked Lists can be:
+.Linked Lists can be:
 - Singly: every item has a pointer to the next node
 - Doubly: every node has a reference to the next and previous object
 - Circular: the last element points to the first one.
-We are going to explore the first two in the next sections.
+
 
 == Singly Linked List
 
-Each element or node is *linked* to the next one by a reference. When a node only has the reference to the next element, it's called *singly linked list*:
+Each element or node is *connected* to the next one by a reference. When a node only has one connection it's called *singly linked list*:
 
 .Singly Linked List Representation: each node has a reference (blue arrow) to the next one.
 image:image19.png[image,width=498,height=97]
 
-
-Usually, a Linked List is referenced by the first element in called *head* (or *root* node). For instance, if you want to get the `cat` element from the example above, then the only way to get there is using the next field on the head node. You would get `art` first, then use the next field recursively until you eventually get the `cat` element.
+Usually, a Linked List is referenced by the first element in called *head* (or *root* node). For instance, if you want to get the `cat` element from the example above, then the only way to get there is using the `next` field on the head node. You would get `art` first, then use the next field recursively until you eventually get the `cat` element.
 
 == Doubly Linked List
 
-When each node has a reference to the next item and also the previous one, then we have a *doubly linked list*.
+When each node has a connection to the `next` item and also the `previous` one, then we have a *doubly linked list*.
 
 .Doubly Linked List: each node has a reference to the next and previous element.
 image:image20.png[image,width=528,height=74]
 
+With a doubly list you can not only move forward but also backward. If you keep the reference to the last element (`cat`) you can step back and reach the middle part.
+
 If we implement the code for the `Node` elements, it would be something like this:
 
 // image:image21.png[image,width=528,height=285]
 
-.Linked List Node
+.Linked List Node Implementation
 [source, javascript]
 ----
 include::{codedir}/data-structures/linked-lists/node.js[tag=snippet]
 ----
 
 == Linked List vs. Array
 
-Arrays allow you to access data anywhere in the collection using an index. However, Linked List visits nodes in sequential order. In the worst case scenario, it takes _O(n)_ to get an element from a Linked List. You might be wondering: Isn’t always an array more efficient with O(1) access time? It depends.
+Arrays allow you to access data anywhere in the collection using an index. However, Linked List visits nodes in sequential order. In the worst case scenario, it takes _O(n)_ to get an element from a Linked List. You might be wondering: Isn’t always an array more efficient with _O(1)_ access time? It depends.
 
-We also have to understand the space complexity to see the trade-offs between arrays and linked lists. An array pre-allocates contiguous blocks of memory. When the array is getting full, it has to copy all the elements over to a new space usually 2x bigger.  It takes _O(n)_ to copy all the items over. On the other hand, LinkedList’s nodes only reserve precisely the amount of memory it needs. They don’t have to be next to each other, nor large chunks of memory have to be booked beforehand like arrays. Linked List is more on a "grow as you go" basis.
+We also have to understand the space complexity to see the trade-offs between arrays and linked lists. An array pre-allocates contiguous blocks of memory. When it is getting full, it has to create a bigger array (usually 2x) and copy all the elements.  It takes _O(n)_ to copy all the items over. On the other hand, LinkedList’s nodes only reserve precisely the amount of memory it needs. They don’t have to be next to each other, nor large chunks of memory have to be booked beforehand like arrays. Linked List is more on a "grow as you go" basis.
 
-Another difference is that adding/deleting at the beginning on an array takes O(n), however, in the linked list is a constant operation O(1) as we will implement later.
+Another difference is that adding/deleting at the beginning on an array takes O(n); however, the linked list is a constant operation O(1) as we will implement later.
 
 A drawback of a linked list is that if you want to insert/delete an element at the end of the list, you would have to navigate the whole collection to find the last one O(n). However, this can be solved by keeping track of the last element in the list. We are going to implement that!
 
@@ -62,7 +63,7 @@ include::{codedir}/data-structures/linked-lists/linked-list.js[tag=constructor]
 }
 ----
 
-In our constructor, we keep a reference of the first (and last node for performance reasons).
+In our constructor, we keep a reference of the `first` and also `last` node for performance reasons.
 
 == Searching by value
 
@@ -77,6 +78,7 @@ include::{codedir}/data-structures/linked-lists/linked-list.js[tag=searchByValue
 If we find the element, we will return the index otherwise `undefined`. The runtime for locating an item by value is _O(n)_.
 
 For finding elements by value or position we are using the following helper function:
+
 .Find elements using a callback
 [source, javascript]
 ----
@@ -134,9 +136,6 @@ Appending an element at the end of the list can be done very effectively if we h
 .Add element to the end of the linked list
 image:image24.png[image,width=498,height=208]
 
-
-In code:
-
 .Linked List's add to the end of the list implementation
 [source, javascript]
 ----
@@ -155,8 +154,6 @@ Let’s do an example, with a doubly linked list. We want to insert the `new` no
 .Inserting node in the middle of a doubly linked list.
 image:image25.png[image,width=528,height=358]
 
-Let’s work in the code to do this:
-
 .Linked List's add to the middle of the list
 [source, javascript]
 ----
@@ -186,8 +183,6 @@ image:image26.png[image,width=528,height=74]
 
 For instance, to remove the head (“art”) node, we change the variable `first` to point to the second node “dog”. We also remove the variable `previous` from the "dog" node, so it doesn't point to the “art” node. The garbage collector will get rid of the “art” node when it seems nothing is using it anymore.
 
-In code, it looks like this:
-
 .Linked List's remove from the beginning of the list
 [source, javascript]
 ----
@@ -206,8 +201,6 @@ image:image27.png[image,width=528,height=221]
 
 For instance, if we want to remove the last node “cat”. We use the last pointer to avoid iterating through the whole list. We check `last.previous` to get the “dog” node and make it the new `last` and remove its next reference to “cat”. Since nothing is pointing to “cat” then is out of the list and eventually is deleted from memory by the garbage collector.
 
-Let’s code this up like this:
-
 .Linked List's remove from the end of the list
 [source, javascript]
 ----
@@ -244,7 +237,7 @@ So far, we have seen two liner data structures with different use cases. Here’
 
 .Big O cheat sheet for Linked List and Array
 |===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
+.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space
 ^|_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)
 | Linked List (singly) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(n)* ^|O(n)

book/chapters/queue.adoc

@@ -1,12 +1,14 @@
 = Queue
 (((Queue)))
 (((Data Structures, Linear, Queue)))
+(((First-In First-out)))
+(((FIFO)))
 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
 image:image30.png[image,width=528,height=171]
 
-A queue is like a line of people at the bank, the person that arrived first is the first to go out as well.
+A queue is like a line of people at the bank; the person that arrived first is the first to go out as well.
 
 Similar to the stack, we only have two operations (insert and remove). In a Queue, we add elements to the back of the list and remove it from the front.
 
@@ -23,7 +25,7 @@ include::{codedir}/data-structures/queues/queue.js[tag=constructor]
 We initialize the Queue creating a linked list. Now, let’s add the `enqueue` and `dequeue` methods.
 
 == Insertion
-
+(((Enqueue)))
 For inserting elements on queue, also know as *enqueue*, we add items to the back of the list using `addLast`:
 
 .Queue's enqueue
@@ -35,7 +37,7 @@ include::{codedir}/data-structures/queues/queue.js[tag=enqueue, indent=0]
 As discussed, this operation has a constant runtime.
 
 == Deletion
-
+(((Dequeue)))
 For removing elements from a queue, also know as *dequeue*, we remove elements from the front of the list using `removeFirst`:
 
 .Queue's dequeue
@@ -63,46 +65,11 @@ You can see that the items are dequeue in the same order they were added, FIFO (
 As an experiment, we can see in the following table that if we had implemented the Queue using an array, its enqueue time would be _O(n)_ instead of _O(1)_. Check it out:
 
 
-.Time complexity for queue operations
+.Time/Space complexity for queue operations
 |===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
+.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space
 ^|_Index/Key_ ^|_Value_ ^|_beginning_ ^|_middle_ ^|_end_ ^|_beginning_ ^|_middle_ ^|_end_
 | Queue (w/array) ^|- ^|- ^|- ^|- ^|*O(n)* ^|- ^|- ^|O(1) ^|O(n)
 | Queue (w/list) ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===
 indexterm:[Runtime, Linear]
-
-= Summary
-
-In this chapter, we explored the most used linear data structures such as Arrays, Linked Lists, Stacks and Queues. We implemented them and discussed the runtime of their operations.
-
-To sum up,
-
-.Use Arrays when…
-* You need to access data in random order fast (using an index).
-* Your data is multi-dimensional (e.g., matrix, tensor).
-
-.Use Linked Lists when:
-* You will access your data sequentially.
-* You want to save memory and only allocate memory as you need it.
-* You want constant time to remove/add from extremes of the list.
-
-.Use a Queue when:
-* You need to access your data in a first-come, first served basis (FIFO).
-* You need to implement a <<Breadth-First Search for Binary Tree, Breadth-First Search>>
-
-.Use a Stack when:
-* You need to access your data as last-in, first-out (LIFO).
-* You need to implement a <<Depth-First Search for Binary Tree, Depth-First Search>>
-
-.Time Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)
-|===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
-^|_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)
-| <<Singly Linked List>> ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(n)* ^|O(n)
-| <<Doubly Linked List>> ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(1) ^|O(1) ^|O(n) ^|*O(1)* ^|O(n)
-| <<Stack>> ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
-| Queue (w/array) ^|- ^|- ^|- ^|- ^|*O(n)* ^|- ^|- ^|O(1) ^|O(n)
-| <<Queue>> (w/list) ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
-|===

book/chapters/stack.adoc

@@ -1,6 +1,8 @@
 = Stack
 (((Stack)))
 (((Data Structures, Linear, Stack)))
+(((Last-In First-out)))
+(((LIFO)))
 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.
@@ -66,9 +68,9 @@ As you can see if we add new items they will be the first to go out to honor LIF
 
 Implementing the stack with an array and linked list would lead to the same time complexity:
 
-.Time complexity for the stack operations
+.Time/Space complexity for the stack operations
 |===
-.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space Complexity
+.2+.^s| Data Structure 2+^s| Searching By 3+^s| Inserting at the 3+^s| Deleting from .2+.^s| Space
 ^|_Index/Key_ ^|_Value_ ^|_beginning_ ^|_middle_ ^|_end_ ^|_beginning_ ^|_middle_ ^|_end_
 | Stack ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===

src/data-structures/linked-lists/linked-list.js

@@ -148,7 +148,7 @@ class LinkedList {
 
   // tag::find[]
   /**
-   * Iterate through the list until callback returns thruthy
+   * Iterate through the list until callback returns a truthy value
    * @example see #get and  #indexOf
    * @param {Function} callback evaluates current node and index.
    *  If any value other than undefined it's returned it will stop the search.