docs: show images on github

amejiarosario · amejiarosario · commit 6f58e27ed511 · 2019-04-11T13:01:26.000-04:00
diff --git a/README.md b/README.md
@@ -32,7 +32,7 @@ You can check out the [dsa.js book](https://gum.co/dsajs) that goes deeper into
 
 <a href="https://gum.co/dsajs"><img src="https://user-images.githubusercontent.com/418605/55248546-60ebad80-5220-11e9-8cb5-85923f44e196.png" height="400px" alt="dsajs algorithms javascript book"></a>
 
-WARNING: Although you can find the [book text on this repo](https://github.com/amejiarosario/dsa.js/blob/master/book/book.adoc), there are some things that doesn't work well with Github's Asciidoc unfortunately, such as rendering Graphviz diagrams, including referenced chunks of code within text and some so on. For better reading experience and nicer presentation you can get the [PDF format here](https://gum.co/dsajs).
+WARNING: Although you can find the [book text on this repo](https://github.com/amejiarosario/dsa.js/blob/master/book/book.adoc), there are some things that doesn't work well with Github's Asciidoc unfortunately. For instance rendering Graphviz diagrams, internal link references, embedding code into docs and so on. For better reading experience and nicer presentation you can get the [PDF format here](https://gum.co/dsajs).
 
 ## Data Structures
 
diff --git a/book/book.adoc b/book/book.adoc
@@ -10,7 +10,6 @@
 :keywords: dsa.js, Algorithms, Data Structures, JavaScript, Coding Interviews, Computer Science, Time Complexity, Linked Lists, Graphs, Binary Search Trees
 :doctype: book
 :media: screen
-:imagesdir: {docdir}/images
 ifeval::["{media}" != "prepress"]
 :front-cover-image: image:cover-a4.png[Front Cover,595,842]
 endif::[]
@@ -25,6 +24,7 @@ endif::[]
 :pdf-style: adrian-screen
 :title-logo-image: image:logo.png[Logo,50,50]
 // custom variables
+:imagesdir: {docdir}/images
 :codedir: ../../src
 :datadir: {docdir}/data
 // :source-highlighter: pygments
diff --git a/book/chapters/algorithms-analysis.adoc b/book/chapters/algorithms-analysis.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Fundamentals of Algorithms Analysis
 
 Probably you are reading this book because you want to write better and faster code.
diff --git a/book/chapters/array.adoc b/book/chapters/array.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Array
 (((Array)))
 (((Data Structures, Linear, Array)))
diff --git a/book/chapters/backtracking.adoc b/book/chapters/backtracking.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Backtracking
 (((Backtracking)))
 (((Algorithmic Techniques, Backtracking)))
diff --git a/book/chapters/big-o-examples.adoc b/book/chapters/big-o-examples.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Big O examples
 // = Eight Running Times You Should Know
 
diff --git a/book/chapters/bubble-sort.adoc b/book/chapters/bubble-sort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Bubble Sort
 (((Bubble Sort)))
 (((Sorting, Bubble Sort)))
diff --git a/book/chapters/divide-and-conquer--fibonacci.adoc b/book/chapters/divide-and-conquer--fibonacci.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Recursive Fibonacci Numbers
 (((Fibonacci)))
 To illustrate how we can solve a problem using divide and conquer, let's write a program to find the n-th Fibonacci number.
diff --git a/book/chapters/dynamic-programming--fibonacci.adoc b/book/chapters/dynamic-programming--fibonacci.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Fibonacci Sequence with Dynamic Programming
 (((Fibonacci)))
 Let's solve the same Fibonacci problem but this time with dynamic programming.
diff --git a/book/chapters/dynamic-programming--intro.adoc b/book/chapters/dynamic-programming--intro.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 (((Dynamic Programming)))
 (((Algorithmic Techniques, Dynamic Programming)))
 Dynamic programming (dp) is a way to solve algorithmic problems with *overlapping subproblems*. Algorithms using dp find the base case and building a solution from the ground-up. Dp _keep track_ of previous results to avoid re-computing the same operations.
diff --git a/book/chapters/dynamic-programming--knapsack-problem.adoc b/book/chapters/dynamic-programming--knapsack-problem.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Knapsack Problem
 
 The knapsack (backpack [big]#🎒#) problem is the following:
diff --git a/book/chapters/dynamic-programming.adoc b/book/chapters/dynamic-programming.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Dynamic Programming
 
 include::dynamic-programming--intro.adoc[]
diff --git a/book/chapters/graph-search.adoc b/book/chapters/graph-search.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Graph Search
 
 Graph search allows you to visit search elements.
diff --git a/book/chapters/graph.adoc b/book/chapters/graph.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Graph
 (((Graph)))
 (((Data Structures, Non-Linear, Graph)))
diff --git a/book/chapters/greedy-algorithms--intro.adoc b/book/chapters/greedy-algorithms--intro.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 (((Greedy Algorithms)))
 (((Algorithmic Techniques, Greedy Algorithms)))
 Greedy algorithms are designed to find a solution by going one step at a time and using heuristics to determine the best choice.
diff --git a/book/chapters/greedy-algorithms--knapsack-problem.adoc b/book/chapters/greedy-algorithms--knapsack-problem.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Fractional Knapsack Problem
 
 We are going to use the "Fractional Knapsack Problem" to learn how to design greedy algorithms. The problem is the following:
diff --git a/book/chapters/insertion-sort.adoc b/book/chapters/insertion-sort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Insertion Sort
 
 (((Sorting, Insertion Sort)))
diff --git a/book/chapters/introduction.adoc b/book/chapters/introduction.adoc
diff --git a/book/chapters/linked-list.adoc b/book/chapters/linked-list.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Linked List
 (((Linked List)))
 (((List)))
diff --git a/book/chapters/map-hashmap-vs-treemap.adoc b/book/chapters/map-hashmap-vs-treemap.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = HashMap vs TreeMap
 
 .A map can be implemented using hash functions or binary search tree:
diff --git a/book/chapters/map-hashmap.adoc b/book/chapters/map-hashmap.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = HashMap
 (((HashMap)))
 (((HashTable)))
diff --git a/book/chapters/map-intro.adoc b/book/chapters/map-intro.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Map
 (((Map)))
 (((Data Structures, Non-Linear, Map)))
diff --git a/book/chapters/map-treemap.adoc b/book/chapters/map-treemap.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = TreeMap
 (((TreeMap)))
 (((Data Structures, Non-Linear, TreeMap)))
diff --git a/book/chapters/merge-sort.adoc b/book/chapters/merge-sort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Merge Sort
 (((Sorting, Merge Sort)))
 (((Merge Sort)))
diff --git a/book/chapters/non-linear-data-structures-intro-advanced.adoc b/book/chapters/non-linear-data-structures-intro-advanced.adoc
diff --git a/book/chapters/queue.adoc b/book/chapters/queue.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Queue
 (((Queue)))
 (((Data Structures, Linear, Queue)))
diff --git a/book/chapters/quick-sort.adoc b/book/chapters/quick-sort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Quicksort
 (((Sorting, QuickSort)))
 (((QuickSort)))
diff --git a/book/chapters/selection-sort.adoc b/book/chapters/selection-sort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Selection Sort
 
 (((Sorting, Selection Sort)))
diff --git a/book/chapters/set.adoc b/book/chapters/set.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Set
 (((Set)))
 (((Data Structures, Non-Linear, Set)))
diff --git a/book/chapters/sorting--summary.adoc b/book/chapters/sorting--summary.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Summary
 
 We explored many algorithms some of them simple and other more performant. Also, we cover the properties of sorting algorithms such as stable, in-place, online and adaptive.
diff --git a/book/chapters/sorting-intro.adoc b/book/chapters/sorting-intro.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Sorting Algorithms
 
 Sorting is one of the most common solutions when we want to extract some insights about a collection of data.
diff --git a/book/chapters/sorting-properties.adoc b/book/chapters/sorting-properties.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Sorting Properties
 
 Sorting implementations with the same time complexity might manipulate the data differently. We want to understand these differences so we can be aware of the side-effects it will have on data or extra resources they will require. For instance, some solutions will need auxiliary memory to store temporary data while sorting while others can do it in place.
diff --git a/book/chapters/stack.adoc b/book/chapters/stack.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Stack
 (((Stack)))
 (((Data Structures, Linear, Stack)))
diff --git a/book/chapters/tim-sort.adoc b/book/chapters/tim-sort.adoc
diff --git a/book/chapters/timsort.adoc b/book/chapters/timsort.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Tim Sort
 
 tim sort is an efficient recursive sorting algorithm that uses "divide and conquer" paradigm to sort faster. It can be implemented in-place so it doesn't require additonal memory.
diff --git a/book/chapters/tree--avl.adoc b/book/chapters/tree--avl.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = AVL Tree
 (((AVL Tree)))
 (((Tree, AVL)))
diff --git a/book/chapters/tree--binary-search-tree.adoc b/book/chapters/tree--binary-search-tree.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Binary Search Tree
 (((Binary Search Tree)))
 (((BST)))
diff --git a/book/chapters/tree--binary-tree-traversal.adoc b/book/chapters/tree--binary-tree-traversal.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Binary Tree Traversal
 (((Binary Tree Traversal)))
 As mentioned before, there are different ways to visit all the nodes or search for a value in a binary tree. On this section, we are going to focus on depth-first tree traversal.
diff --git a/book/chapters/tree--search.adoc b/book/chapters/tree--search.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Tree Search & Traversal
 
 So far we covered, how to insert/delete/search values in a binary search tree (BST).
diff --git a/book/chapters/tree--self-balancing-rotations.adoc b/book/chapters/tree--self-balancing-rotations.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Self-balancing Binary Search Trees
 
 Binary Search Trees (BST) are an excellent data structure to find elements very fast _O(log n)_.
diff --git a/book/chapters/tree.adoc b/book/chapters/tree.adoc
@@ -1,3 +1,8 @@
+ifndef::imagesdir[]
+:imagesdir: ../images
+:codedir: ../../src
+endif::[]
+
 = Tree
 (((Tree)))
 (((Data Structures, Non-Linear, Tree)))
diff --git a/book/custom-variables.adoc b/book/custom-variables.adoc
@@ -0,0 +1,2 @@
+:imagesdir: {docdir}/images
+:codedir: ../../src
