docs(readme): make links relative

Author: amejiarosario

README.md

@@ -65,7 +65,7 @@ and then you can import it into your programs or CLI
 const { LinkedList, Queue, Stack } = require('dsa.js');
 ```
 
-For a full list of all the exposed data structures and algorithms [see](https://github.com/amejiarosario/dsa.js/blob/master/src/index.js).
+For a full list of all the exposed data structures and algorithms [see](src/index.js).
 
 
 ## Features
@@ -89,15 +89,15 @@ This material is going to teach you to:
 
 ## What's Inside
 
-All the code and explanations are available on this repo. You can dig through the links and code examples from the ([src folder](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/tree/master/src)). However, the inline code examples are not expanded (because of Github's asciidoc limitations) but you can follow the path and see the implementation.
+All the code and explanations are available on this repo. You can dig through the links and code examples from the ([src folder](src)). However, the inline code examples are not expanded (because of Github's asciidoc limitations) but you can follow the path and see the implementation.
 
 _Note: If you prefer to consume the information in a more linear fashion then the [book format](https://books.adrianmejia.com/dsajs-data-structures-algorithms-javascript/) would be more appropriate for you._
 
 The topics are divided in 4 main categories as you can see below:
 
 _(You can click on the ⯈ to expand the topics)_
 
-### 📈 [Algorithms Analysis](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part01-algorithms-analysis.asc)
+### 📈 [Algorithms Analysis](book/part01-algorithms-analysis.asc)
 
 <!-- - Computer Science nuggets without all the mumbo-jumbo.
 - Learn how to compare algorithms using Big O notation.
@@ -112,11 +112,11 @@ _(You can click on the ⯈ to expand the topics)_
 
 ---
 
-### [Computer Science nuggets without all the mumbo-jumbo](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/algorithms-analysis.asc)
+### [Computer Science nuggets without all the mumbo-jumbo](book/content/part01/algorithms-analysis.asc)
 
 #### Learn to calculate run time from code examples
 
-![Translating lines of code to an approximate number of operations](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/raw/master/book/images/image4.png)
+![Translating lines of code to an approximate number of operations](book/images/image4.png)
 
 ---
 
@@ -129,16 +129,16 @@ _(You can click on the ⯈ to expand the topics)_
 
 ---
 
-### [Learn how to compare algorithms using Big O notation.](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/big-o-examples.asc#finding-if-an-array-is-empty)
+### [Learn how to compare algorithms using Big O notation.](book/content/part01/big-o-examples.asc#finding-if-an-array-is-empty)
 
 #### Comparing algorithms using Big O notation
 
 Let's say you want to find the duplicates on an array.
 Using Big O notation we can compare different implementations that do exactly the same but
 they take different time to complete.
 
-- [Optimal solution using a map](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/big-o-examples.asc#linear-example)
-- [Finding duplicates in an array (naïve approach)](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/big-o-examples.asc#quadratic-example)
+- [Optimal solution using a map](book/content/part01/big-o-examples.asc#linear-example)
+- [Finding duplicates in an array (naïve approach)](book/content/part01/big-o-examples.asc#quadratic-example)
 
 ---
 
@@ -151,11 +151,11 @@ they take different time to complete.
 
 ---
 
-[8 examples to explain with code how to calculate time complexity](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/big-o-examples.asc#summary)
+[8 examples to explain with code how to calculate time complexity](book/content/part01/big-o-examples.asc#summary)
 
 #### Most common time complexities
 
-[![image](https://user-images.githubusercontent.com/418605/59617342-2a715080-90f4-11e9-9de9-9315fb0133f9.png)](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part01/big-o-examples.asc#summary)
+[![image](https://user-images.githubusercontent.com/418605/59617342-2a715080-90f4-11e9-9de9-9315fb0133f9.png)](book/content/part01/big-o-examples.asc#summary)
 
 <!-- - Constant time: _O(1)_
 - Logarithmic time: _O(log n)_
@@ -168,14 +168,14 @@ they take different time to complete.
 
 #### Time complexity graph
 
-![Most common time complexities](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/raw/master/book/images/image5.png)
+![Most common time complexities](book/images/image5.png)
 
 ---
 
 </details>
 </blockquote>
 
-### 🥞 [Linear Data Structures](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part02-linear-data-structures.asc)
+### 🥞 [Linear Data Structures](book/part02-linear-data-structures.asc)
 
 <!-- - Understand the ins and outs of the most common data structures.
 - When to use an Array or Linked List. Know the tradeoffs.
@@ -190,29 +190,29 @@ they take different time to complete.
 
 ---
 
-#### [Understand the ins and outs of the most common data structures](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part02-linear-data-structures.asc)
+#### [Understand the ins and outs of the most common data structures](book/part02-linear-data-structures.asc)
 
 
-- [Arrays](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part02/array.asc): Built-in in most languages so not implemented here. [Array Time complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part02/array.asc#array-complexity)
+- [Arrays](book/content/part02/array.asc): Built-in in most languages so not implemented here. [Array Time complexity](book/content/part02/array.asc#array-complexity)
     <!-- [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Array). -->
 
-- [Linked List](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part02/linked-list.asc): each data node has a link to the next (and
+- [Linked List](book/content/part02/linked-list.asc): each data node has a link to the next (and
     previous).
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/linked-lists/linked-list.js)
+    [Code](src/data-structures/linked-lists/linked-list.js)
     |
-    [Linked List Time Complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part02/linked-list.asc#linked-list-complexity-vs-array-complexity)
+    [Linked List Time Complexity](book/content/part02/linked-list.asc#linked-list-complexity-vs-array-complexity)
     <!-- [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Linked-Lists) -->
 
-- [Queue](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part02/queue.asc): data flows in a "first-in, first-out" (FIFO) manner.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/queues/queue.js)
+- [Queue](book/content/part02/queue.asc): data flows in a "first-in, first-out" (FIFO) manner.
+    [Code](src/data-structures/queues/queue.js)
     |
-    [Queue Time Complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part02/queue.asc#queue-complexity)
+    [Queue Time Complexity](book/content/part02/queue.asc#queue-complexity)
     <!-- [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Queues) -->
 
-- [Stack](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part02/stack.asc): data flows in a "last-in, first-out" (LIFO) manner.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/data-structures/stacks/stack.js)
+- [Stack](book/content/part02/stack.asc): data flows in a "last-in, first-out" (LIFO) manner.
+    [Code](src/data-structures/stacks/stack.js)
     |
-    [Stack Time Complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part02/stack.asc#stack-complexity)
+    [Stack Time Complexity](book/content/part02/stack.asc#stack-complexity)
     <!-- [Post](https://adrianmejia.com/blog/2018/04/28/data-structures-time-complexity-for-beginners-arrays-hashmaps-linked-lists-stacks-queues-tutorial/#Stacks) -->
 
 ---
@@ -225,7 +225,7 @@ they take different time to complete.
 
 ---
 
-#### [When to use an Array or Linked List. Know the tradeoffs](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part02/array-vs-list-vs-queue-vs-stack.asc)
+#### [When to use an Array or Linked List. Know the tradeoffs](book/content/part02/array-vs-list-vs-queue-vs-stack.asc)
 
 Use Arrays when…
 - You need to access data in random order fast (using an index).
@@ -246,19 +246,19 @@ Use Linked Lists when:
 
   ---
 
-  #### [Build a List, Stack and a Queue from scratch](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part02-linear-data-structures.asc)
+  #### [Build a List, Stack and a Queue from scratch](book/part02-linear-data-structures.asc)
 
   Build any of these data structures from scratch:
-  - [Linked List](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/src/data-structures/linked-lists/linked-list.js)
-  - [Stack](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/src/data-structures/stacks/stack.js)
-  - [Queue](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/src/data-structures/queues/queue.js)
+  - [Linked List](src/data-structures/linked-lists/linked-list.js)
+  - [Stack](src/data-structures/stacks/stack.js)
+  - [Queue](src/data-structures/queues/queue.js)
 
   ---
 
   </details>
 </blockquote>
 
-### 🌲 [Non-Linear Data Structures](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part03-graph-data-structures.asc)
+### 🌲 [Non-Linear Data Structures](book/part03-graph-data-structures.asc)
 <!-- - Understand one of the most versatile data structure of all: Maps -->
 <!-- - Know the properties of Graphs and Trees. -->
 <!-- - Implement a binary search tree for fast lookups. -->
@@ -271,13 +271,13 @@ Use Linked Lists when:
 
 ---
 
-#### [HashMaps](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/map.asc)
+#### [HashMaps](book/content/part03/map.asc)
 
 Learn how to implement different types of Maps such as:
-- [HashMap](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/hashmap.asc)
-- [TreeMap](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/treemap.asc)
+- [HashMap](book/content/part03/hashmap.asc)
+- [TreeMap](book/content/part03/treemap.asc)
 
-Also, [learn the difference between the different Maps implementations](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/time-complexity-graph-data-structures.asc):
+Also, [learn the difference between the different Maps implementations](book/content/part03/time-complexity-graph-data-structures.asc):
 
 - `HashMap` is more time-efficient. A `TreeMap` is more space-efficient.
 - `TreeMap` search complexity is *O(log n)*, while an optimized `HashMap` is *O(1)* on average.
@@ -296,60 +296,60 @@ Also, [learn the difference between the different Maps implementations](https://
 
 ---
 
-#### [Know the properties of Graphs and Trees](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part03-graph-data-structures.asc)
+#### [Know the properties of Graphs and Trees](book/part03-graph-data-structures.asc)
 
-##### [Graphs](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/graph.asc)
+##### [Graphs](book/content/part03/graph.asc)
 
 Know all the graphs properties with many images and illustrations.
 
-![graph example with USA airports](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/raw/master/book/images/image46.png)
+![graph example with USA airports](book/images/image46.png)
 
  **Graphs**: data **nodes** that can have a connection or **edge** to
     zero or more adjacent nodes. Unlike trees, nodes can have multiple
     parents, loops.
-    [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/graphs/graph.js)
+    [Code](src/data-structures/graphs/graph.js)
     |
-    [Graph Time Complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part03/graph.asc#graph-complexity)
+    [Graph Time Complexity](book/content/part03/graph.asc#graph-complexity)
 
-#### [Trees](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/tree-intro.asc)
+#### [Trees](book/content/part03/tree-intro.asc)
 
 Learn all the different kinds of trees and its properties.
 
-![tree data structure properties](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/raw/master/book/images/image31.jpg)
+![tree data structure properties](book/images/image31.jpg)
 
 - **Trees**: data nodes has zero or more adjacent nodes a.k.a.
     children. Each node can only have one parent node otherwise is a
     graph not a tree.
-    [Code](https://github.com/amejiarosario/algorithms.js/tree/master/src/data-structures/trees)
+    [Code](src/data-structures/trees)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part03/tree-intro.asc)
+    [Docs](book/content/part03/tree-intro.asc)
     <!-- [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/) -->
 
     - **Binary Trees**: same as tree but only can have two children at
         most.
-        [Code](https://github.com/amejiarosario/algorithms.js/tree/master/src/data-structures/trees)
+        [Code](src/data-structures/trees)
         |
-        [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part03/tree-intro.asc#binary-tree)
+        [Docs](book/content/part03/tree-intro.asc#binary-tree)
         <!-- [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/#Binary-Trees) -->
 
     - **Binary Search Trees** (BST): same as binary tree, but the
         nodes value keep this order `left < parent < right`.
-        [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/binary-search-tree.js)
+        [Code](src/data-structures/trees/binary-search-tree.js)
         |
-        [BST Time complexity](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part03/binary-search-tree.asc#tree-complexity)
+        [BST Time complexity](book/content/part03/binary-search-tree.asc#tree-complexity)
         <!-- [Post](https://adrianmejia.com/blog/2018/06/11/data-structures-for-beginners-trees-binary-search-tree-tutorial/#Binary-Search-Tree-BST) -->
 
     - **AVL Trees**: Self-balanced BST to maximize look up time.
-        [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/avl-tree.js)
+        [Code](src/data-structures/trees/avl-tree.js)
         |
-        [AVL Tree docs](https://github.com/amejiarosario/dsa.js/blob/master/book/C-AVL-tree.asc)
+        [AVL Tree docs](book/C-AVL-tree.asc)
         |
-        [Self-balancing & tree rotations docs](https://github.com/amejiarosario/dsa.js/blob/master/book/B-self-balancing-binary-search-trees.asc)
+        [Self-balancing & tree rotations docs](book/B-self-balancing-binary-search-trees.asc)
         <!-- [Post](https://adrianmejia.com/blog/2018/07/16/self-balanced-binary-search-trees-with-avl-tree-data-structure-for-beginners/) -->
 
     - **Red-Black Trees**: Self-balanced BST more loose than AVL to
         maximize insertion speed.
-        [Code](https://github.com/amejiarosario/algorithms.js/blob/master/src/data-structures/trees/red-black-tree.js)
+        [Code](src/data-structures/trees/red-black-tree.js)
 
 ---
 
@@ -362,12 +362,12 @@ Learn all the different kinds of trees and its properties.
 
 ---
 
-#### [Implement a binary search tree for fast lookups](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part03/binary-search-tree.asc)
+#### [Implement a binary search tree for fast lookups](book/content/part03/binary-search-tree.asc)
 
 - Learn how to add/remove/update values in a tree:
-![inserting node in a tree](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/raw/master/book/images/image36.png)
+![inserting node in a tree](book/images/image36.png)
 
-- [How to make a tree balanced?](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/B-self-balancing-binary-search-trees.asc)
+- [How to make a tree balanced?](book/B-self-balancing-binary-search-trees.asc)
 
 From unbalanced BST to balanced BST
 ```
@@ -384,7 +384,7 @@ From unbalanced BST to balanced BST
   </details>
 </blockquote>
 
-### ⚒ [Algorithmic Toolbox](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part04-algorithmic-toolbox.asc)
+### ⚒ [Algorithmic Toolbox](book/part04-algorithmic-toolbox.asc)
 
 <!-- - Never get stuck solving a problem with 7 simple steps. -->
 <!-- - Master the most popular sorting algorithms (mergesort, quicksort, insertion sort, ...) -->
@@ -398,7 +398,7 @@ From unbalanced BST to balanced BST
 
 ---
 
-#### [Never get stuck solving a problem with 7 simple steps](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part04-algorithmic-toolbox.asc)
+#### [Never get stuck solving a problem with 7 simple steps](book/part04-algorithmic-toolbox.asc)
 
 1. Understand the problem
 1. Build a simple example (no edge cases yet)
@@ -408,7 +408,7 @@ From unbalanced BST to balanced BST
 1. Write Code, yes, now you can code.
 1. Test your written code
 
-Full details [here](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part04-algorithmic-toolbox.asc)
+Full details [here](book/part04-algorithmic-toolbox.asc)
 
 ---
 
@@ -420,34 +420,34 @@ Full details [here](https://github.com/amejiarosario/dsa.js-data-structures-and-
 
 ---
 
-#### [Master the most popular sorting algorithms](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part04/sorting-algorithms.asc)
+#### [Master the most popular sorting algorithms](book/content/part04/sorting-algorithms.asc)
 
 We are going to explore three basic sorting algorithms O(n2) which have low overhead:
   - Bubble Sort.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/bubble-sort.js)
+    [Code](src/algorithms/sorting/bubble-sort.js)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part04/bubble-sort.asc)
+    [Docs](book/content/part04/bubble-sort.asc)
 
   - Insertion Sort.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/insertion-sort.js)
+    [Code](src/algorithms/sorting/insertion-sort.js)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part04/insertion-sort.asc)
+    [Docs](book/content/part04/insertion-sort.asc)
 
   - Selection Sort.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/selection-sort.js)
+    [Code](src/algorithms/sorting/selection-sort.js)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part04/selection-sort.asc)
+    [Docs](book/content/part04/selection-sort.asc)
 
 and then discuss efficient sorting algorithms O(n log n) such as:
   - Merge Sort.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/merge-sort.js)
+    [Code](src/algorithms/sorting/merge-sort.js)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part04/merge-sort.asc)
+    [Docs](book/content/part04/merge-sort.asc)
 
   - Quick sort.
-    [Code](https://github.com/amejiarosario/dsa.js/blob/master/src/algorithms/sorting/quick-sort.js)
+    [Code](src/algorithms/sorting/quick-sort.js)
     |
-    [Docs](https://github.com/amejiarosario/dsa.js/blob/master/book/content/part04/quick-sort.asc)
+    [Docs](book/content/part04/quick-sort.asc)
 
 ---
 
@@ -459,13 +459,13 @@ and then discuss efficient sorting algorithms O(n log n) such as:
 
 ---
 
-#### [Learn different approaches to solve algorithmic problems](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/part04-algorithmic-toolbox.asc)
+#### [Learn different approaches to solve algorithmic problems](book/part04-algorithmic-toolbox.asc)
 
 We are going to discuss the following techniques for solving algorithms problems:
-- [Greedy Algorithms](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/bbook/content/part04/greedy-algorithms.asc): makes greedy choices using heuristics to find the best solution without looking back.
-- [Dynamic Programming](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part04/dynamic-programming.asc): a technique for speeding up recursive algorithms when there are many _overlapping subproblems_. It uses _memoization_ to avoid duplicating work.
-- [Divide and Conquer](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part04/divide-and-conquer.asc): _divide_ problems into smaller pieces, _conquer_ each subproblem and then _join_ the results.
-- [Backtracking](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/book/content/part04/backtracking.asc): search _all (or some)_ possible paths. However, it stops and _go back_ as soon as notice the current solution is not working.
+- [Greedy Algorithms](book/content/part04/greedy-algorithms.asc): makes greedy choices using heuristics to find the best solution without looking back.
+- [Dynamic Programming](book/content/part04/dynamic-programming.asc): a technique for speeding up recursive algorithms when there are many _overlapping subproblems_. It uses _memoization_ to avoid duplicating work.
+- [Divide and Conquer](book/content/part04/divide-and-conquer.asc): _divide_ problems into smaller pieces, _conquer_ each subproblem and then _join_ the results.
+- [Backtracking](book/content/part04/backtracking.asc): search _all (or some)_ possible paths. However, it stops and _go back_ as soon as notice the current solution is not working.
 - _Brute Force_: generate all possible solutions and tries all of them. (Use it as a last resort or as the starting point to optimize it with other techniques).
 
 ---
@@ -515,4 +515,4 @@ The best way to support this project is buying the [book](https://books.adrianme
 
 ## License
 
-[![License](https://img.shields.io/:license-mit-blue.svg?style=flat-square)](https://github.com/amejiarosario/dsa.js-data-structures-and-algorithms-in-javascript/blob/master/LICENSE)
+[![License](https://img.shields.io/:license-mit-blue.svg?style=flat-square)](LICENSE)