labling tables

Author: amejiarosario

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

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

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
 |<>
 |<>
 |===
+// end::table[]

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)
-|<>
-|#<>, #<>
-
-|O(log n)
-|<>
-|<>
-
-|O(n)
-|<>
-|<>
-
-|O(n log n)
-|<>
-|<>
-
-|O(n^2^)
-|<>
-|<>
-
-|O(n^3^)
-|<>
-|<>
-
-|O(2^n^)
-|<>
-|<>
-
-|O(n!)
-|<>
-|<>
-|===
+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",]

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.

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 <>
+(((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)
 | <> (w/list) ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===
+// end::table[]

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)))
 

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)))

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)*.

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