cheatsheet refactored

Author: amejiarosario

book/chapters/algorithms-analysis.adoc

@@ -47,7 +47,7 @@ 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!
 
 To give you a clearer picture of how different algorithms perform as the input size grows, take a look at the following problems and how their relative execution time changes as the input size increases.
-(((Tables, Algorithms input size vs Time)))
+(((Tables, Intro, Algorithms input size vs Time)))
 
 .Relationship between algorithm input size and time taken to complete
 [cols=",,,,,",options="header",]
@@ -111,7 +111,7 @@ When we are comparing algorithms, we don't want to have complex expressions. Wha
 TIP: Asymptotic analysis describes the behavior of functions as their inputs approach to infinity.
 
 In the previous example, we analyzed `getMin` with an array of size 3; what happen size is 10 or 10k or a million?
-(((Tables, Operations of 3n+3)))
+(((Tables, Intro, Operations of 3n+3)))
 
 .Operations performed by an algorithm with a time complexity of `3n + 3`
 [cols=",,",options="header",]
@@ -152,8 +152,9 @@ WARNING: Don't drop terms that multiplying other terms. _O(n log n)_ is not equi
 There are many common notations like polynomial, _O(n^2^)_ like we saw in the `getMin` example; constant _O(1)_ and many more that we are going to explore in the next chapter.
 
 Again, time complexity is not a direct measure of how long a program takes to execute but rather how many operations it performs in given the input size. Nevertheless, there’s a relationship between time complexity and clock time as we can see in the following table.
+(((Tables, Intro, Input size vs clock time by Big O)))
 
-(((Tables, Input size vs clock time by Big O)))
+// tag::table[]
 .How long an algorithm takes to run based on their time complexity and input size
 [cols=",,,,,,",options="header",]
 |===============================================================
@@ -164,6 +165,7 @@ Again, time complexity is not a direct measure of how long a program takes to ex
 |100k |< 1 sec. |< 1 sec. |1 second |3 hours |∞ |∞
 |1M |< 1 sec. |1 second |20 seconds |12 days |∞ |∞
 |===============================================================
+// end::table[]
 
 This just an illustration since in different hardware the times will be slightly different.
 

book/chapters/array.adoc

@@ -203,7 +203,7 @@ Runtime: O(1).
 == Array Complexity
 
 To sum up, the time complexity on an array is:
-(((Tables, Array Complexities)))
+(((Tables, Linear DS, Array Complexities)))
 
 // tag::table[]
 .Time/Space complexity for the array operations
@@ -217,7 +217,7 @@ To sum up, the time complexity on an array is:
 (((Constant)))
 (((Runtime, Constant)))
 
-(((Tables, JavaScript Array buit-in operations Complexities)))
+(((Tables, Linear DS, JavaScript Array buit-in operations Complexities)))
 .Array Operations timex complexity
 |===
 | Operation | Time Complexity | Usage

book/chapters/big-o-examples.adoc

@@ -245,7 +245,7 @@ Factorial start very slow and then it quickly becomes uncontrollable. A word siz
 == Summary
 
 We went through 8 of the most common time complexities and provided examples for each of them. Hopefully, this will give you a toolbox to analyze algorithms.
-(((Tables, Common time complexities and examples)))
+(((Tables, Intro, Common time complexities and examples)))
 
 // tag::table[]
 .Most common algorithmic running times and their examples

book/chapters/chapter3.adoc

@@ -60,5 +60,24 @@ include::graph-search.adoc[]
 = Summary
 
 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.
+(((Tables, Non-Linear DS, BST/Maps/Sets Complexities)))
+
+// tag::table[]
+.Time and Space Complexity for Non-Linear Data Structures
+|===
+.2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
+^|_Index/Key_ ^|_Value_
+| <<Binary Search Tree, BST (unbalanced)>> ^|- ^|O(n) ^|O(n) ^|O(n) ^|O(n)
+| <<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)
+| <<HashMap>> (optimized) ^|O(1)* ^|O(n) ^|O(1)* ^|O(1)* ^|O(1)*
+| <<TreeMap>> (Red-Black Tree) ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(log n)
+| <<HashSet>> ^|- ^|O(n) ^|O(1)* ^|O(1)* ^|O(1)*
+| <<TreeSet>> ^|- ^|O(n) ^|O(log n) ^|O(log n) ^|O(log n)
+|===
+{empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
+// end::table[]
+
+]
 
 :leveloffset: -1

book/chapters/chapter4.adoc

@@ -33,6 +33,9 @@ include::merge-sort.adoc[]
 <<<
 include::quick-sort.adoc[]
 
+<<<
+include::sorting--summary.adoc[]
+
 :leveloffset: -1
 
 

book/chapters/cheatsheet.adoc

@@ -7,71 +7,23 @@ This section summerize what we are  going to cover in the rest of this book.
 
 include::big-o-examples.adoc[tag=table]
 
-.How long an algorithm takes to run based on their time complexity and input size
-[cols=",,,,,,",options="header",]
-|===============================================================
-|Input Size |O(1) |O(n) |O(n log n) |O(n^2^) |O(2^n^) |O(n!)
-|1 |< 1 sec. |< 1 sec. |< 1 sec. |< 1 sec. |< 1 sec. |< 1 sec.
-|10 |< 1 sec. |< 1 sec. |< 1 sec. |< 1 sec. |< 1 sec. |4 seconds
-|10k |< 1 sec. |< 1 sec. |< 1 sec. |2 minutes |∞ |∞
-|100k |< 1 sec. |< 1 sec. |1 second |3 hours |∞ |∞
-|1M |< 1 sec. |1 second |20 seconds |12 days |∞ |∞
-|===============================================================
+include::algorithms-analysis.adoc[tag=table]
 
 == Linear Data Structures
 
-.Time and 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
-^|_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)
-|===
+include::linear-data-structures-outro.adoc[tag=table]
 
 == Trees and Maps Data Structures
 
 This section covers Binary Search Tree (BST) time complexity (Big O).
 
-.Time and Space Complexity for Non-Linear Data Structures
-|===
-.2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
-^|_Index/Key_ ^|_Value_
-| BST (**un**balanced) ^|- ^|O(n) ^|O(n) ^|O(n) ^|O(n)
-| 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)
-| Hash Map (optimized) ^|O(1)* ^|O(n) ^|O(1)* ^|O(1)* ^|O(1)*
-| Tree Map (Red-Black Tree) ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(log n)
-| HashSet ^|- ^|O(n) ^|O(1)* ^|O(1)* ^|O(1)*
-| TreeSet ^|- ^|O(n) ^|O(log n) ^|O(log n) ^|O(log n)
-|===
-{empty}* = Amortized run time. E.g. rehashing might affect run time to *O(n)*.
+include::chapter3.adoc[tag=table]
 
-
-.Time complexity for a Graph data structure
-|===
-.2+.^s| Data Structure 2+^s| Vertices 2+^s| Edges .2+^.^s| Space Complexity
-^|_Add_ ^|_Remove_ ^|_Add_ ^|_Remove_
-| Graph (adj. matrix) ^| O(\|V\|^2^) ^| O(\|V\|^2^) ^|O(1) ^|O(1) ^|O(\|V\|^2^)
-| Graph (adj. list w/array) ^| O(1) ^| O(\|V\| + \|E\|)) ^|O(1) ^|O(\|V\| + \|E\|) ^|O(\|V\| + \|E\|)
-| Graph (adj. list w/HashSet) ^| O(1) ^| O(\|V\|)) ^|O(1) ^|O(\|V\|) ^|O(\|V\| + \|E\|)
-|===
+include::graph.adoc[tag=table]
 
 == Sorting Algorithms
 
-.Sorting algorithms comparison
-|===
-| Algorithms     | Runtime    | Space       | Stable | In-place | Online | Adaptive | Comments
-| Insertion sort | O(n^2^)    | O(1)        | Yes    | Yes      | Yes    | Yes      |
-| Selection sort | O(n^2^)    | O(1)        | Yes    | Yes      | Yes    | Yes      |
-| Bubble sort    | O(n^2^)    | O(1)        | Yes    | Yes      | Yes    | Yes      |
-| Merge sort     | O(n log n) | O(n)        | Yes    | No       | No     | No       |
-| Quicksort     | O(n log n) | O(log n)    | Yes    | No       | No     | No       |
-// | Tim sort       | O(n log n) | O(log n)    | Yes    | No       | No     | Yes      | Hybrid of merge and insertion sort
-|===
+include::sorting--summary.adoc[tag=table]
 
 // https://algs4.cs.princeton.edu/cheatsheet/
 // http://bigocheatsheet.com/

book/chapters/graph.adoc

@@ -283,7 +283,7 @@ include::{codedir}/data-structures/graphs/node.js[tag=removeAdjacent, indent=0]
 ----
 
 == Graph Complexity
-(((Tables, Graph adjacency matrix/list complexities)))
+(((Tables, Non-Linear DS, Graph adjacency matrix/list complexities)))
 
 // tag::table[]
 .Time complexity for a Graph data structure

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

@@ -18,7 +18,7 @@ In this part of the book, we explored the most used linear data structures such
 .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>>
-(((Tables, Array/Lists/Stack/Queue complexities)))
+(((Tables, Linear DS, Array/Lists/Stack/Queue complexities)))
 
 // tag::table[]
 .Time/Space Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)

book/chapters/linked-list.adoc

@@ -233,7 +233,7 @@ Notice that we are using the `get` method to get the node at the current positio
 == Linked List Complexity vs. Array Complexity
 
 So far, we have seen two liner data structures with different use cases. Here’s a summary:
-(((Tables, Array/Lists complexities)))
+(((Tables, Linear DS, Array/Lists complexities)))
 
 // tag::table[]
 .Big O cheat sheet for Linked List and Array

book/chapters/map-hashmap-vs-treemap.adoc

@@ -15,7 +15,7 @@
 == TreeMap Time complexity vs HashMap
 
 As we discussed so far, there is a trade-off between the implementations.
-(((Tables, HashMap/TreeMap complexities)))
+(((Tables, Non-Linear DS, HashMap/TreeMap complexities)))
 
 // tag::table[]
 .Time complexity for different Maps implementations