Merge pull request amejiarosario#24 from amejiarosario/github-fixes

GitHub fixes

Author: amejiarosario

.circleci/config.yml

@@ -104,7 +104,7 @@ jobs: # a collection of steps
 
       - run:
           name: generate PDF
-          command: cd book/config && make VERSION="$(npx -c 'echo "$npm_package_version"')" pdf
+          command: cd book/config && make VERSION="$(npx -c 'echo "$npm_package_version"')"
 
       - store_artifacts:
           path: book/dist

.gitignore

@@ -72,7 +72,6 @@ local.properties
 # Ruby
 ######################
 /.bundle/
-/Gemfile.lock
 
 ######################
 # Package Files
@@ -136,13 +135,13 @@ Desktop.ini
 # ln -s ~/OneDrive/Authoring/dsaJS/asciidoc/book/fonts .
 # ln -s ~/OneDrive/Authoring/dsaJS/asciidoc/book/images .
 ######################
-Gemfile
-Gemfile.lock
-Makefile
-_conf
-_resources
-extensions
-fonts
+# Gemfile
+# Gemfile.lock
+# Makefile
+# _conf
+# _resources
+# extensions
+# fonts
 
 
 ######################

README.md

@@ -0,0 +1,39 @@
+[appendix]
+[[a-time-complexity-cheatsheet]]
+== Cheatsheet
+
+This section summerize what we are  going to cover in the rest of this book.
+
+=== Runtimes
+
+include::content/part01/big-o-examples.asc[tag=table]
+
+include::content/part01/algorithms-analysis.asc[tag=table]
+
+=== Linear Data Structures
+
+include::content/part02/array-vs-list-vs-queue-vs-stack.asc[tag=table]
+
+=== Trees and Maps Data Structures
+
+This section covers Binary Search Tree (BST) time complexity (Big O).
+
+include::content/part03/time-complexity-graph-data-structures.asc[tag=table]
+
+include::content/part03/graph.asc[tag=table]
+
+=== Sorting Algorithms
+
+include::content/part04/sorting-algorithms.asc[tag=table]
+
+// // https://algs4.cs.princeton.edu/cheatsheet/
+// // http://bigocheatsheet.com/
+
+// // https://en.wikipedia.org/wiki/Timsort (Tim Peters)
+// // https://bugs.python.org/file4451/timsort.txt
+// // https://www.youtube.com/watch?v=emeME__917E&list=PLMCXHnjXnTntLcLmA5SqhMspm7burHi3m
+
+// // https://en.wikipedia.org/wiki/Sorting_algorithm
+// // http://sorting.at/
+// // https://www.toptal.com/developers/sorting-algorithms
+// // https://www.infopulse.com/blog/timsort-sorting-algorithm/

book/A-time-complexity-cheatsheet.asc

@@ -1,9 +1,6 @@
-ifndef::imagesdir[]
-:imagesdir: ../images
-:codedir: ../../src
-endif::[]
-
-= Self-balancing Binary Search Trees
+[appendix]
+[[b-self-balancing-binary-search-trees]]
+== 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.
@@ -31,12 +28,13 @@ 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)))
 We can do single rotations left and right and also we can do double rotations.
 Let's go one by one.
 
-=== Single Right Rotation
+==== Single Right Rotation
 
 Right rotation moves a node on the right as a child of another node.
 
@@ -48,7 +46,7 @@ So, we move node 3 as the right child of the previous child.
 .Single right rotation implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/tree-rotations.js[tag=rightRotation]
+include::../src/data-structures/trees/tree-rotations.js[tag=rightRotation]
 ----
 
 .In the `rightRotation` we identify 3 nodes:
@@ -64,7 +62,7 @@ Take a look at the implementation.
 .Swap Parent and Child Implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/tree-rotations.js[tag=swapParentChild]
+include::../src/data-structures/trees/tree-rotations.js[tag=swapParentChild]
 ----
 
 After `swapParentChild`, we have the following:
@@ -93,14 +91,14 @@ Check out the <<Single Right Rotation, rightRotation>> implementation again. It
 This rotation is also known as `RR rotation`.
 
 
-=== Single Left Rotation
+==== Single Left Rotation
 
 Left rotation is similar to the `rightRotation` we explained above.
 
 .Single left rotation implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/tree-rotations.js[tag=leftRotation]
+include::../src/data-structures/trees/tree-rotations.js[tag=leftRotation]
 ----
 
 As you can see, this function is just the opposite of `rightRotation`. Where ever we used the right now we use the left here and vice versa.
@@ -111,36 +109,37 @@ If you are curious about the `setRightAndUpdateParent` and `setLeftAndUpdatePare
 .Set and update parent implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/binary-tree-node.js[tag=setAndUpdateParent]
+include::../src/data-structures/trees/binary-tree-node.js[tag=setAndUpdateParent]
 ----
 
 You can also check out the full
 https://github.com/amejiarosario/dsa.js/blob/adfd8a660bbe0a7068fd7881aff9f51bdb9f92ae/src/data-structures/trees/binary-tree-node.js#L9[binary tree node implementation].
 
-=== Left Right Rotation
+==== Left Right Rotation
 
 This time are we going to do a double rotation.
 
 .Left-Right rotation implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/tree-rotations.js[tag=leftRightRotation]
+include::../src/data-structures/trees/tree-rotations.js[tag=leftRightRotation]
 ----
 
 As you can see we do a left and then a right rotation. This rotation is also known as `LR rotation`
 
-=== Right Left Rotation
+==== Right Left Rotation
 
 Very similar to `leftRightRotation`. The difference is that we rotate right and then left.
 
 .Right-Left rotation implementation
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/tree-rotations.js[tag=rightLeftRotation]
+include::../src/data-structures/trees/tree-rotations.js[tag=rightLeftRotation]
 ----
 
 This rotation is also referred to as `RL rotation`.
 
-== Self-balancing trees implementations
+=== Self-balancing trees implementations
 
 So far, we have study how to make tree rotations which are the basis for self-balancing trees. There are different implementations of self-balancing trees such a Red-Black Tree and AVL Tree.
+

book/chapters/tree-self-balancing-rotations.adoc renamed to book/B-self-balancing-binary-search-trees.asc

@@ -1,44 +1,41 @@
-ifndef::imagesdir[]
-:imagesdir: ../images
-:codedir: ../../src
-endif::[]
-
-= AVL Tree
+[appendix]
+[[c-avl-tree]]
+== AVL Tree
 (((AVL Tree)))
 (((Tree, AVL)))
 AVL Tree is named after their inventors (**A**delson-**V**elsky and **L**andis).
 This self-balancing tree keeps track of subtree sizes to know if a rebalance is needed or not.
 We can compare the size of the left and right subtrees using a balance factor.
 
 [NOTE]
-====
+=====
 
 The *balanced factor* on each node is calculated recursively as follows:
 
 ----
 Balance Factor = (left subtree height) - (right subtree height)
 ----
 
-====
+=====
 
 The implementation will go in the BST node class.
 We will need two methods to calculate the left and right subtree, and with those, we can get the balance factor.
 
 .Balance Factor methods on the BST node
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/binary-tree-node.js[tag=avl, indent=0]
+include::../src/data-structures/trees/binary-tree-node.js[tag=avl, indent=0]
 ----
 
 
-== Implementing AVL Tree
+=== Implementing AVL Tree
 
 Implementing an AVL Tree is not too hard since it builds upon what we did in the Binary Search Tree.
 
 .AVL Tree class
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/avl-tree.js[tag=AvlTree]
+include::../src/data-structures/trees/avl-tree.js[tag=AvlTree]
 ----
 
 As you can see, the AVL tree inherits from the BST class.
@@ -48,7 +45,7 @@ This function checks if the tree is symmetrical after every change to the tree.
 .Balance Upstream for AVL tree
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/avl-tree.js[tag=balanceUpstream]
+include::../src/data-structures/trees/avl-tree.js[tag=balanceUpstream]
 ----
 
 This function recursively goes from the modified node to the root checking if each node in between is balanced.
@@ -57,10 +54,10 @@ Now, let's examine how does the balancing works on AVL tree.
 .Balance method for AVL tree
 [source, javascript]
 ----
-include::{codedir}/data-structures/trees/avl-tree.js[tag=balance]
+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 <<Tree Rotations>> in case you want a refresher.
+You can review <<b-self-balancing-binary-search-trees#tree-rotations>> in case you want a refresher.