labling tables

amejiarosario · amejiarosario · commit 780b28a819ba · 2019-03-28T14:19:24.000-04:00
diff --git a/book/chapters/algorithms-analysis.adoc b/book/chapters/algorithms-analysis.adoc
@@ -47,6 +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.
+(((table)))
 
 .Relationship between algorithm input size and time taken to complete
 [cols=",,,,,",options="header",]
@@ -110,8 +111,9 @@ 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?
+(((table)))
 
-.Operations performed by an algorithm with a time complexity of 3n+3
+.Operations performed by an algorithm with a time complexity of `3n + 3`
 [cols=",,",options="header",]
 |===========================
 |n (size) |Operations |total
diff --git a/book/chapters/array.adoc b/book/chapters/array.adoc
@@ -203,7 +203,9 @@ Runtime: O(1).
 == Array Complexity
 
 To sum up, the time complexity on an array is:
+(((table)))
 
+// tag::table[]
 .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
@@ -215,7 +217,7 @@ To sum up, the time complexity on an array is:
 (((Constant)))
 (((Runtime, Constant)))
 
-Array Operations
+.Array Operations timex complexity
 |===
 | Operation | Time Complexity | Usage
 | push ^| O(1) | Insert element to the right side.
@@ -224,3 +226,4 @@ Array Operations
 | shift ^| O(n) | Remove leftmost element.
 | splice ^| O(n) | Insert and remove from anywhere.
 |===
+//end::table
diff --git a/book/chapters/big-o-examples.adoc b/book/chapters/big-o-examples.adoc
@@ -245,7 +245,9 @@ 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.
+(((table)))
 
+// tag::table[]
 .Most common algorithmic running times and their examples
 [cols="2,2,5",options="header"]
 |===
@@ -285,3 +287,4 @@ We went through 8 of the most common time complexities and provided examples for
 |<<Factorial>>
 |<<factorial-example>>
 |===
+// end::table[]
diff --git a/book/chapters/cheatsheet.adoc b/book/chapters/cheatsheet.adoc
@@ -5,45 +5,7 @@ This section summerize what we are  going to cover in the rest of this book.
 
 == Runtimes
 
-.Most common algorithmic running times and their examples
-[cols="2,2,5",options="header"]
-|===
-|Big O Notation
-|Name
-|Example(s)
-
-|O(1)
-|<<Constant>>
-|#<<constant-example>>, #<<linked-list-inserting-beginning>>
-
-|O(log n)
-|<<Logarithmic>>
-|<<logarithmic-example>>
-
-|O(n)
-|<<Linear>>
-|<<linear-example>>
-
-|O(n log n)
-|<<Linearithmic>>
-|<<linearithmic-example>>
-
-|O(n^2^)
-|<<Quadratic>>
-|<<quadratic-example>>
-
-|O(n^3^)
-|<<Cubic>>
-|<<cubic-example>>
-
-|O(2^n^)
-|<<Exponential>>
-|<<exponential-example>>
-
-|O(n!)
-|<<Factorial>>
-|<<factorial-example>>
-|===
+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",]
diff --git a/book/chapters/graph.adoc b/book/chapters/graph.adoc
@@ -284,6 +284,9 @@ include::{codedir}/data-structures/graphs/node.js[tag=removeAdjacent, indent=0]
 
 == Graph Complexity
 
+(((table)))
+
+// tag::table[]
 .Time complexity for a Graph data structure
 |===
 .2+.^s| Data Structure 2+^s| Vertices 2+^s| Edges .2+^.^s| Space Complexity
@@ -292,5 +295,6 @@ include::{codedir}/data-structures/graphs/node.js[tag=removeAdjacent, indent=0]
 | 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\|)
 |===
+// end::table[]
 
 As you can see using a `HashSet` on for the adjacency list make a performance improvement.
diff --git a/book/chapters/linear-data-structures-outro.adoc b/book/chapters/linear-data-structures-outro.adoc
@@ -18,7 +18,9 @@ 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>>
+(((table)))
 
+// tag::table[]
 .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
@@ -30,3 +32,4 @@ In this part of the book, we explored the most used linear data structures such
 | Queue (w/array) ^|- ^|- ^|- ^|- ^|*O(n)* ^|- ^|- ^|O(1) ^|O(n)
 | <<Queue>> (w/list) ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===
+// end::table[]
diff --git a/book/chapters/linked-list.adoc b/book/chapters/linked-list.adoc
@@ -233,8 +233,9 @@ 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:
+(((table)))
 
-
+// tag::table[]
 .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
@@ -243,6 +244,7 @@ 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)
 |===
+// end::table[]
 (((Linear)))
 (((Runtime, Linear)))
 
diff --git a/book/chapters/map-hashmap-vs-treemap.adoc b/book/chapters/map-hashmap-vs-treemap.adoc
@@ -15,7 +15,9 @@
 == TreeMap Time complexity vs HashMap
 
 As we discussed so far, there is a trade-off between the implementations.
+(((table)))
 
+// tag::table[]
 .Time complexity for different Maps implementations
 |===
 .2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
@@ -25,6 +27,7 @@ As we discussed so far, there is a trade-off between the implementations.
 | Tree Map (Red-Black Tree) ^|O(log n) ^|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[]
 
 (((Linear)))
 (((Runtime, Linear)))
diff --git a/book/chapters/map-hashmap.adoc b/book/chapters/map-hashmap.adoc
@@ -287,7 +287,9 @@ https://github.com/amejiarosario/dsa.js/blob/7694c20d13f6c53457ee24fbdfd3c0ac571
 == HashMap time complexity
 
 Hash Map it’s very optimal for searching values by key in constant time *O(1)*. However, searching by value is not any better than an array since we have to visit every value *O(n)*.
+(((table)))
 
+// tag::table[]
 .Time complexity for a Hash Map
 |===
 .2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
@@ -296,6 +298,7 @@ Hash Map it’s very optimal for searching values by key in constant time *O(1)*
 | Hash Map (optimized) ^|O(1)* ^|O(n) ^|O(1)* ^|O(1)* ^|O(1)*
 |===
 {empty}* = Amortized run time. E.g. rehashing might affect run time.
+// end::table[]
 
 indexterm:[Runtime, Linear]
 As you can notice we have amortized times since, in the unfortunate case of a rehash, it will take O(n) while it resizes. After that, it will be *O(1)*.
diff --git a/book/chapters/preface.adoc b/book/chapters/preface.adoc
@@ -11,7 +11,7 @@ This publication is designed to be concise, intending to serve software develope
 
 This book is for software developers familiar with JavaScript looking to improve their problem-solving skills or preparing for a job interview.
 
-NOTE: You can apply the concepts in this book to any programming language. However, instead of doing examples on pseudo-code we are going to use JavaScript to implement the code examples.
+NOTE: You can apply the concepts in this book to any programming language. However, instead of doing examples in pseudo-code we are going to use JavaScript to implement the code examples.
 
 == What you need for this book
 
diff --git a/book/chapters/queue.adoc b/book/chapters/queue.adoc
@@ -63,13 +63,15 @@ You can see that the items are dequeue in the same order they were added, FIFO (
 == Queue Complexity
 
 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:
+(((table)))
 
-
+// tag::table[]
 .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
 ^|_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)
 |===
+// end::table[]
 indexterm:[Runtime, Linear]
diff --git a/book/chapters/set.adoc b/book/chapters/set.adoc
@@ -205,6 +205,9 @@ This method has an average runtime of *O(1)*.
 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)*.
 
+(((table)))
+
+// 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
@@ -213,6 +216,7 @@ rehash happens, it will take *O(n)* instead of *O(1)*. A `TreeSet` is always *O(
 | 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[]
 
 indexterm:[Runtime, Linear]
 (((Logarithmic)))
diff --git a/book/chapters/stack.adoc b/book/chapters/stack.adoc
@@ -67,12 +67,15 @@ As you can see if we add new items they will be the first to go out to honor LIF
 == Stack Complexity
 
 Implementing the stack with an array and linked list would lead to the same time complexity:
+(((table)))
 
+// tag::table[]
 .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
 ^|_Index/Key_ ^|_Value_ ^|_beginning_ ^|_middle_ ^|_end_ ^|_beginning_ ^|_middle_ ^|_end_
 | Stack ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===
+// end::table[]
 
 It's not very common to search for values on a stack (other Data Structures are better suited for this). Stacks especially useful for implementing <<Depth-First Search for Binary Tree, Depth-First Search>>.
diff --git a/book/chapters/tree--binary-search-tree.adoc b/book/chapters/tree--binary-search-tree.adoc
@@ -164,13 +164,16 @@ The tree on the left is unbalanced. It looks like a Linked List and has the same
 == Tree Complexity
 
 We can sum up the tree operations using Big O notation:
+(((table)))
 
+// tag::table[]
 .Time complexity for a Binary Search Tree (BST)
 |===
 .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)
 |===
+// end::table[]
 indexterm:[Runtime, Linear]
 indexterm:[Runtime, Logarithmic]
