fix(book): multiple broken links and bump epub version

fixes amejiarosario#60

Author: amejiarosario

book/A-time-complexity-cheatsheet.asc

@@ -1,6 +1,5 @@
 [appendix]
-[[a-time-complexity-cheatsheet]]
-== Cheatsheet
+== Cheatsheet [[a-time-complexity-cheatsheet]]
 
 This section summerize what we are  going to cover in the rest of this book.
 

book/B-self-balancing-binary-search-trees.asc

@@ -1,6 +1,5 @@
 [appendix]
-[[b-self-balancing-binary-search-trees]]
-== Self-balancing Binary Search Trees
+== Self-balancing Binary Search Trees [[b-self-balancing-binary-search-trees]]
 
 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.
@@ -28,8 +27,7 @@ As you might notice, we balanced the tree in the example by doing a rotation.
 To be more specific we rotated node `1` to the left to balance the tree.
 Let's examine all the possible rotation we can do to balance a tree.
 
-[[tree-rotations]]
-=== Tree Rotations
+=== Tree Rotations [[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.

book/C-AVL-tree.asc

@@ -1,6 +1,5 @@
 [appendix]
-[[c-avl-tree]]
-== AVL Tree
+== AVL Tree [[c-avl-tree]]
 (((AVL Tree)))
 (((Tree, AVL)))
 AVL Tree is named after their inventors (**A**delson-**V**elsky and **L**andis).
@@ -60,4 +59,4 @@ include::../src/data-structures/trees/avl-tree.js[tag=balance]
 The first thing we do is to see if one subtree is longer than the other.
 If so, then we check the children balance to determine if need a single or double rotation and in which direction.
 
-You can review <<b-self-balancing-binary-search-trees#tree-rotations>> in case you want a refresher.
+You can review <<tree-rotations>> in case you want a refresher.

book/config

@@ -31,7 +31,7 @@ In this part of the book, we explored the most used linear data structures such
 |===
 .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_
-| <<part02-linear-data-structures#array>> ^|O(1) ^|O(n) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(n) ^|O(1) ^|O(n)
+| <<array-chap>> ^|O(1) ^|O(n) ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|O(n) ^|O(1) ^|O(n)
 | <<part02-linear-data-structures#singly-linked-list>> ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|*O(n)* ^|O(1) ^|O(n) ^|*O(n)* ^|O(n)
 | <<part02-linear-data-structures#doubly-linked-list>> ^|O(n) ^|O(n) ^|O(1) ^|O(n) ^|*O(1)* ^|O(1) ^|O(n) ^|*O(1)* ^|O(n)
 | <<part02-linear-data-structures#stack>> ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)

book/content/part02/array-vs-list-vs-queue-vs-stack.asc

@@ -24,7 +24,7 @@ In short, you set `key`/`value` pair and then you can get the `value` using the
 The attractive part of Maps is that they are very performant usually *O(1)* or *O(log n)* depending on the implementation. We can implement the maps using two different underlying data structures:
 
 * *HashMap*: it’s a map implementation using an *array* and a *hash function*. The job of the hash function is to convert the `key` into an index that maps to the `value`. Optimized HashMap can have an average runtime of *O(1)*.
-* *TreeMap*: it’s a map implementation that uses a self-balanced Binary Search Tree (like <<c-avl-tree#>>). The BST nodes store the key, and the value and nodes are sorted by key guaranteeing an *O(log n)* look up.
+* *TreeMap*: it’s a map implementation that uses a self-balanced Binary Search Tree (like <<c-avl-tree>>). The BST nodes store the key, and the value and nodes are sorted by key guaranteeing an *O(log n)* look up.
 
 <<<
 include::hashmap.asc[]

book/content/part03/map.asc

@@ -14,7 +14,7 @@ In this section, we learned about Graphs applications, properties and how we can
 .2+.^s| Data Structure 2+^s| Searching By .2+^.^s| Insert .2+^.^s| Delete .2+^.^s| Space Complexity
 ^|_Index/Key_ ^|_Value_
 | <<part03-graph-data-structures#bst, BST (unbalanced)>> ^|- ^|O(n) ^|O(n) ^|O(n) ^|O(n)
-| <<b-self-balancing-binary-search-trees#, BST (balanced)>> ^|- ^|O(log n) ^|O(log n) ^|O(log n) ^|O(n)
+| <<b-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)
 | <<part03-graph-data-structures#hashmap, HashMap>> (optimized) ^|O(1) ^|O(n) ^|O(1)* ^|O(1) ^|O(n)
 | <<part03-graph-data-structures#treemap, TreeMap>> (Red-Black Tree) ^|O(log n) ^|O(n) ^|O(log n) ^|O(log n) ^|O(n)

book/content/part03/time-complexity-graph-data-structures.asc

@@ -3,7 +3,7 @@
 
 === What is in this book?
 
-_{doctitle}_ is a book that can be read from cover to cover, where each section builds on top of the previous one. Also, it can be used as a reference manual where developers can refresh specific topics before an interview or look for ideas to solve a problem optimally. (Check out the <<a-time-complexity-cheatsheet#,Time Complexity Cheatsheet>> and <<index#, topical index>>)
+_{doctitle}_ is a book that can be read from cover to cover, where each section builds on top of the previous one. Also, it can be used as a reference manual where developers can refresh specific topics before an interview or look for ideas to solve a problem optimally. (Check out the <<a-time-complexity-cheatsheet,Time Complexity Cheatsheet>> and <<index, topical index>>)
 
 This publication is designed to be concise, intending to serve software developers looking to get a firm conceptual understanding of data structures in a quick yet in-depth fashion. After reading this book, the reader should have a fundamental knowledge of algorithms, including when and where to apply it, what are the trade-offs of using one data structure over the other. The reader will then be able to make intelligent decisions about algorithms and data structures in their projects.
 

book/content/preface.asc

@@ -1,5 +1,4 @@
 [index]
-[[index]]
-== Index
+== Index [[index]]
 
 ifndef::backend-pdf[Topical index only available on the PDF version.]

book/index.asc

@@ -6,7 +6,7 @@ Data Structures comes in many flavors. There’s no one to rule them all. You ha
 Even though in your day-to-day, you might not need to re-implementing them, knowing how they work internally would help you know when to use one 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:
-- <<part02-linear-data-structures#array>>
+- <<array-chap>>
 - <<part02-linear-data-structures#linked-list>>
 - <<part02-linear-data-structures#stack>>
 - <<part02-linear-data-structures#queue>>