Skip to content

Commit 543933d

Browse files
amejiarosarioamejiarosario
committed
works with PDF!!
1 parent 44e5770 commit 543933d

File tree

150 files changed

+7947
-249
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

150 files changed

+7947
-249
lines changed

‎.gitignore

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -137,11 +137,11 @@ Desktop.ini
137137
######################
138138
# Gemfile
139139
# Gemfile.lock
140-
Makefile
141-
_conf
142-
_resources
143-
extensions
144-
fonts
140+
# Makefile
141+
# _conf
142+
# _resources
143+
# extensions
144+
# fonts
145145

146146

147147
######################

‎book-pro/A-time-complexity-cheatsheet.asc

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
[[time-complexity-cheatsheet]]
2+
[appendix]
3+
== Time Complexity Cheatsheet
4+
5+
This section summerize what we are going to cover in the rest of this book.
6+
7+
// === Runtimes
8+
9+
// include::big-o-examples.adoc[tag=table]
10+
11+
// include::algorithms-analysis.adoc[tag=table]
12+
13+
// === Linear Data Structures
14+
15+
// include::linear-data-structures-outro.adoc[tag=table]
16+
17+
// === Trees and Maps Data Structures
18+
19+
// This section covers Binary Search Tree (BST) time complexity (Big O).
20+
21+
// include::part3.adoc[tag=table]
22+
23+
// include::graph.adoc[tag=table]
24+
25+
// === Sorting Algorithms
26+
27+
// include::sorting-summary.adoc[tag=table]
28+
29+
// // https://algs4.cs.princeton.edu/cheatsheet/
30+
// // http://bigocheatsheet.com/
31+
32+
// // https://en.wikipedia.org/wiki/Timsort (Tim Peters)
33+
// // https://bugs.python.org/file4451/timsort.txt
34+
// // https://www.youtube.com/watch?v=emeME__917E&list=PLMCXHnjXnTntLcLmA5SqhMspm7burHi3m
35+
36+
// // https://en.wikipedia.org/wiki/Sorting_algorithm
37+
// // http://sorting.at/
38+
// // https://www.toptal.com/developers/sorting-algorithms
39+
// // https://www.infopulse.com/blog/timsort-sorting-algorithm/

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

Lines changed: 143 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,143 @@
1+
[appendix]
2+
== Self-balancing Binary Search Trees
3+
4+
Binary Search Trees (BST) are an excellent data structure to find elements very fast _O(log n)_.
5+
However, when the BST branches have different branch sizes, then the performance suffers.
6+
In the worst case, all nodes can go to one side (e.g., right) and then the search time would be linear.
7+
At this point searching element won't be any better on that tree than an array or linked list. Yikes!
8+
9+
Self-balanced trees will automatically rebalance the tree when an element is inserted to keep search performance.
10+
We balance a tree by making the height (distance from a node to the root) of any leaf on the tree as similar as possible.
11+
12+
.From unbalanced BST to balanced BST
13+
[source, javascript]
14+
----
15+
1 2
16+
\ / \
17+
2 => 1 3
18+
\
19+
3
20+
----
21+
22+
In the example above:
23+
- Unbalanced BST: height node `3` is 2 and height node `2` is 1.
24+
- Balanced BST: height node `3` is 1 and height node `2` is 1. Much better!
25+
26+
As you might notice, we balanced the tree in the example by doing a rotation.
27+
To be more specific we rotated node `1` to the left to balance the tree.
28+
Let's examine all the possible rotation we can do to balance a tree.
29+
30+
=== Tree Rotations
31+
(((Tree Rotations)))
32+
We can do single rotations left and right and also we can do double rotations.
33+
Let's go one by one.
34+
35+
==== Single Right Rotation
36+
37+
Right rotation moves a node on the right as a child of another node.
38+
39+
Take a look at the `@example` in the code below.
40+
As you can see we have an unbalanced tree `4-3-2-1`.
41+
We want to balance the tree, for that we need to do a right rotation of node 3.
42+
So, we move node 3 as the right child of the previous child.
43+
44+
.Single right rotation implementation
45+
[source, javascript]
46+
----
47+
include::../src/data-structures/trees/tree-rotations.js[tag=rightRotation]
48+
----
49+
50+
.In the `rightRotation` we identify 3 nodes:
51+
- `node` this is the node we want to rotate to the right. E.g., `node 3`
52+
- `newParent` this is the new parent after the rotation. E.g., `node 2`
53+
- `grandparent` this the current's node parent. E.g. `node 4`.
54+
55+
The `swapParentChild` as it name says, swap the children.
56+
For our example, it swaps `node 4`'s left children from `node 3` to `node 2`.
57+
58+
Take a look at the implementation.
59+
60+
.Swap Parent and Child Implementation
61+
[source, javascript]
62+
----
63+
include::../src/data-structures/trees/tree-rotations.js[tag=swapParentChild]
64+
----
65+
66+
After `swapParentChild`, we have the following:
67+
----
68+
4
69+
/
70+
2 - 3*
71+
/
72+
1
73+
----
74+
75+
Still not quite what we want.
76+
So, `newParent.setRightAndUpdateParent(node)` will make `node 3` the right child of `node 2`.
77+
Finally, we remove the left child of `node 3` to be `null`.
78+
79+
----
80+
4
81+
/
82+
2
83+
/ \
84+
1 3*
85+
----
86+
87+
Check out the <<Single Right Rotation, rightRotation>> implementation again. It should make more sense to you now.
88+
89+
This rotation is also known as `RR rotation`.
90+
91+
92+
==== Single Left Rotation
93+
94+
Left rotation is similar to the `rightRotation` we explained above.
95+
96+
.Single left rotation implementation
97+
[source, javascript]
98+
----
99+
include::../src/data-structures/trees/tree-rotations.js[tag=leftRotation]
100+
----
101+
102+
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.
103+
This rotation is also known as `LL rotation`.
104+
105+
If you are curious about the `setRightAndUpdateParent` and `setLeftAndUpdateParent`. Here's the implementation:
106+
107+
.Set and update parent implementation
108+
[source, javascript]
109+
----
110+
include::../src/data-structures/trees/binary-tree-node.js[tag=setAndUpdateParent]
111+
----
112+
113+
You can also check out the full
114+
https://github.com/amejiarosario/dsa.js/blob/adfd8a660bbe0a7068fd7881aff9f51bdb9f92ae/src/data-structures/trees/binary-tree-node.js#L9[binary tree node implementation].
115+
116+
==== Left Right Rotation
117+
118+
This time are we going to do a double rotation.
119+
120+
.Left-Right rotation implementation
121+
[source, javascript]
122+
----
123+
include::../src/data-structures/trees/tree-rotations.js[tag=leftRightRotation]
124+
----
125+
126+
As you can see we do a left and then a right rotation. This rotation is also known as `LR rotation`
127+
128+
==== Right Left Rotation
129+
130+
Very similar to `leftRightRotation`. The difference is that we rotate right and then left.
131+
132+
.Right-Left rotation implementation
133+
[source, javascript]
134+
----
135+
include::../src/data-structures/trees/tree-rotations.js[tag=rightLeftRotation]
136+
----
137+
138+
This rotation is also referred to as `RL rotation`.
139+
140+
=== Self-balancing trees implementations
141+
142+
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.
143+

‎book-pro/C-AVL-tree.asc

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
[appendix]
2+
== AVL Tree
3+
(((AVL Tree)))
4+
(((Tree, AVL)))
5+
AVL Tree is named after their inventors (**A**delson-**V**elsky and **L**andis).
6+
This self-balancing tree keeps track of subtree sizes to know if a rebalance is needed or not.
7+
We can compare the size of the left and right subtrees using a balance factor.
8+
9+
[NOTE]
10+
=====
11+
12+
The *balanced factor* on each node is calculated recursively as follows:
13+
14+
----
15+
Balance Factor = (left subtree height) - (right subtree height)
16+
----
17+
18+
=====
19+
20+
The implementation will go in the BST node class.
21+
We will need two methods to calculate the left and right subtree, and with those, we can get the balance factor.
22+
23+
.Balance Factor methods on the BST node
24+
[source, javascript]
25+
----
26+
include::../src/data-structures/trees/binary-tree-node.js[tag=avl, indent=0]
27+
----
28+
29+
30+
=== Implementing AVL Tree
31+
32+
Implementing an AVL Tree is not too hard since it builds upon what we did in the Binary Search Tree.
33+
34+
.AVL Tree class
35+
[source, javascript]
36+
----
37+
include::../src/data-structures/trees/avl-tree.js[tag=AvlTree]
38+
----
39+
40+
As you can see, the AVL tree inherits from the BST class.
41+
The insert and remove operations work the same as in the BST, except that at the end we call `balanceUpstream`.
42+
This function checks if the tree is symmetrical after every change to the tree. If the tree went out of balance, it would execute the appropriated rotation to fix it.
43+
44+
.Balance Upstream for AVL tree
45+
[source, javascript]
46+
----
47+
include::../src/data-structures/trees/avl-tree.js[tag=balanceUpstream]
48+
----
49+
50+
This function recursively goes from the modified node to the root checking if each node in between is balanced.
51+
Now, let's examine how does the balancing works on AVL tree.
52+
53+
.Balance method for AVL tree
54+
[source, javascript]
55+
----
56+
include::../src/data-structures/trees/avl-tree.js[tag=balance]
57+
----
58+
59+
The first thing we do is to see if one subtree is longer than the other.
60+
If so, then we check the children balance to determine if need a single or double rotation and in which direction.
61+
62+
You can review <<Tree Rotations>> in case you want a refresher.

‎book-pro/Find the largest sum.svg

Lines changed: 86 additions & 0 deletions
Loading

0 commit comments

Comments
 (0)