Merge pull request amejiarosario#73 from amejiarosario/feat/tree-problems

Feat/tree problems

Author: amejiarosario

book/D-interview-questions-solutions.asc

@@ -83,14 +83,14 @@ A better solution is to eliminate the 2nd for loop and only do one pass.
 Algorithm:
 
 - Do one pass through all the prices
-    - Keep track of the minimum price seen so far.
-    - calculate `profit = currentPrice - minPriceSoFar`
-    - Keep track of the maximun profit seen so far.
+    ** Keep track of the minimum price seen so far.
+    ** calculate `profit = currentPrice - minPriceSoFar`
+    ** Keep track of the maximun profit seen so far.
 - Return maxProfit.
 
 [source, javascript]
 ----
-include::interview-questions/buy-sell-stock.js[tag=description,solution]
+include::interview-questions/buy-sell-stock.js[tags=description;solution]
 ----
 
 The runtime is `O(n)` and the space complexity of `O(1)`.
@@ -118,14 +118,14 @@ Another case to take into consideration is that lists might have different lengt
 
 - Have a pointer for each list
 - While there's a pointer that is not null, visite them
-    - Compare each list node's value and take the smaller one.
-    - Advance the pointer of the taken node to the next one.
+    ** Compare each list node's value and take the smaller one.
+    ** Advance the pointer of the taken node to the next one.
 
 *Implementation*:
 
 [source, javascript]
 ----
-include::interview-questions/merge-lists.js[tag=description,solution]
+include::interview-questions/merge-lists.js[tags=description;solution]
 ----
 
 Notice that we used a "dummy" node or "sentinel node" to have some starting point for the final list.
@@ -163,14 +163,14 @@ A better way to solve this problem is iterating over each character on both list
 
 - Set a pointer to iterate over each node in the lists.
 - For each node, have an index (starting at zero) and compare if both lists have the same data.
-    - When the index reaches the last character on the current node, we move to the next node.
-    - If we found that a character from one list doesn't match the other, we return `false`.
+    ** When the index reaches the last character on the current node, we move to the next node.
+    ** If we found that a character from one list doesn't match the other, we return `false`.
 
 *Implementation*:
 
 [source, javascript]
 ----
-include::interview-questions/linkedlist-same-data.js[tag=description,solution]
+include::interview-questions/linkedlist-same-data.js[tags=description;solution]
 ----
 
 The function `findNextPointerIndex` is a helper to navigate each character on a linked list.
@@ -206,8 +206,8 @@ This is a parsing problem, and usually, stacks are good candidates for them.
 
 - Create a mapping for each opening bracket to its closing counterpart.
 - Iterate through the string
-    - When we found an opening bracket, insert the corresponding closing bracket into the stack.
-    - When we found a closing bracket, pop from the stack and make sure it corresponds to the current character.
+    ** When we found an opening bracket, insert the corresponding closing bracket into the stack.
+    ** When we found a closing bracket, pop from the stack and make sure it corresponds to the current character.
 - Check the stack is empty. If there's a leftover, it means that something didn't close properly.
 
 *Implementation*:
@@ -242,10 +242,10 @@ Here's an idea: start backward, so we know when there's a warmer temperature bef
 *Algorithm*:
 
 - Traverse the daily temperatures backward
-  - Push each temperature to a stack.
-  - While the current temperature is larger than the one at the top of the stack, pop it.
-  - If the stack is empty, then there's no warmer weather ahead, so it's 0.
-  - If the stack has an element, calculate the index delta.
+  ** Push each temperature to a stack.
+  ** While the current temperature is larger than the one at the top of the stack, pop it.
+  ** If the stack is empty, then there's no warmer weather ahead, so it's 0.
+  ** If the stack has an element, calculate the index delta.
 
 *Implementation*:
 
@@ -275,7 +275,7 @@ The stack contains the indexes rather than the temperatures themselves.
 [#queue-q-recent-counter]
 include::content/part02/queue.asc[tag=queue-q-recent-counter]
 
-We are asked to keep track of the request's count only within a given time window. A queue is a perfect application for this. We can add any new request to the	 Queue. Also, we need to check if the oldest element is outside the time window. If so, we remove it from the queue.
+We are asked to keep track of the request's count only within a given time window. A queue is a perfect application for this. We can add any new request to the  Queue. Also, we need to check if the oldest element is outside the time window. If so, we remove it from the queue.
 
 *Algorithm*:
 
@@ -288,7 +288,7 @@ We are asked to keep track of the request's count only within a given time windo
 
 [source, javascript]
 ----
-include::interview-questions/recent-counter.js[tag=description,solution]
+include::interview-questions/recent-counter.js[tags=description;solution]
 ----
 
 Notice that we enqueue every request, and then we check all the ones that have "expire" and remove them from the queue.
@@ -311,27 +311,122 @@ This game is perfect to practice working with Queues. There are at least two opp
 - If the new location has food, remove that eaten food from its queue and place the next food on the map (if any).
 - If the new position doesn't have food, remove the tail of the snake since it moved.
 - If the snake new position hits itself, game over (return -1). To make this check, we have 2 options:
-    - Queue: we can visit all the elements on the snake's queue (body) and check if a new position collides. That's `O(n)`
-    - Set: we can maintain a `set` with all the snake locations, so the check is `O(1)`.
+    ** Queue: we can visit all the elements on the snake's queue (body) and check if a new position collides. That's `O(n)`
+    ** Set: we can maintain a `set` with all the snake locations, so the check is `O(1)`.
 - Move the snake's head to a new location (enqueue)
 - Return the score (snake's length - 1);
 
 *Implementation*:
 
 [source, javascript]
 ----
-include::interview-questions/design-snake-game.js[tag=description,solution]
+include::interview-questions/design-snake-game.js[tags=description;solution]
 ----
 
 As you can see, we opted for using a set to trade speed for memory.
 
 *Complexity Analysis*:
 
-- Time: `O(1)`. Insert/Remove from Queue is constant time. Check for body collisions is `O(1)` when using a set. If instead of a set, you traversed the snake's queue to find a collision, it would be `O(n)`.  Here`n` is the snake's max length, which is the size of the screen (height x width).
+- Time: `O(1)`. Insert/Remove from Queue is constant time. Check for body collisions is `O(1)` when using a set. If instead of a set, you traversed the snake's queue to find a collision, it would be `O(n)`.  Here`n` is the snake's max length, which is the screen size (height x width).
 - Space: `O(n + m)`. `m` is the number of food items, and `n` is the snake's maximum size (height x width).
 
 
 
+:leveloffset: +1
+
+=== Solutions for Binary Tree Questions
+(((Interview Questions Solutions, Binary Tree)))
+
+:leveloffset: -1
+
+[#binary-tree-q-diameter-of-binary-tree]
+include::content/part03/binary-search-tree-traversal.asc[tag=binary-tree-q-diameter-of-binary-tree]
+
+We are asked to find the longest path on a binary tree that might or might not pass through the root node.
+
+We can calculate the height (distance from root to farthest leaf) of a binary tree using this recursive function:
+
+[source, javascript]
+----
+function getHeight(node) {
+  if (!node) return 0;
+  const leftHeight = getHeight(node.left);
+  const rightHeight = getHeight(node.right);
+  return 1 + Math.max(leftHeight, rightHeight);
+}
+----
+
+That function will give us the height from the furthest leaf to the root. However, the problem says that it might or might not go through the root.
+In that case, we can keep track of the maximum distance (`leftHeight + rightHeight`) seen so far.
+
+*Algorithm*:
+
+- Initialize diameter to `0`
+- Recursively find the height of the tree from the root.
+- Keep track of the maximum diameter length seen so far (left + right).
+- Return the diameter.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/diameter-of-binary-tree.js[tags=description;solution]
+----
+
+We are using `Math.max` to keep track of the longest diameter seen.
+
+*Complexity Analysis*:
+
+- Time: `O(n)`, where `n` is each of the tree nodes. We visite each one once.
+- Space: `O(n)`. We use `O(1)` variables, but because we are using the `height` recursive function, we use the implicit call stack, thus `O(n)`.
+
+
+
+
+[#binary-tree-q-binary-tree-right-side-view]
+include::content/part03/binary-search-tree-traversal.asc[tag=binary-tree-q-binary-tree-right-side-view]
+
+The first thing that might come to mind when you have to visit a tree, level by level, is BFS.
+We can visit the tree using a Queue and keep track when a level ends, and the new one starts.
+
+Since during BFS, we dequeue one node and enqueue their two children (left and right), we might have two levels (current and next one). For this problem, we need to know what the last node on the current level is.
+
+.There are several ways to solve this problem using BFS. Here are some ideas:
+- *1 Queue + Sentinel node*: we can use a special character in the `Queue` like `'*'` or `null` to indicate the level's change. So, we would start something like this `const queue = new Queue([root, '*']);`.
+- *2 Queues*: using a "special" character might be seen as hacky, so you can also opt to keep two queues: one for the current level and another for the next level.
+- *1 Queue + size tracking*: we track the Queue's `size` before the children are enqueued. That way, we know where the current level ends.
+
+We are going to implement BFS with "1 Queue + size tracking", since it's arguably the most elegant.
+
+*Algorithm*:
+
+- Enqueue root
+- While the queue has an element
+    ** Check the current size of the queue
+    ** Dequeue only `size` times, and for each dequeued node, enqueue their children.
+    ** Check if the node is the last one in its level and add it to the answer.
+
+*Implementation*:
+
+[source, javascript]
+----
+include::interview-questions/binary-tree-right-side-view.js[tags=description;solution]
+----
+
+This problem is also possible to be solved using DFS. The trick is to start with the right child and add it to the solution when it is the first one on its level.
+
+[source, javascript]
+----
+include::interview-questions/binary-tree-right-side-view.js[tag=dfs]
+----
+
+The complexity of any of the BFS methods or DFS is similar.
+
+*Complexity Analysis*:
+
+- Time: `O(n)`. We visit every node, once.
+- Space: `O(n)`. For BFS, the worst-case space is given by the maximum *width*. That is when the binary tree is complete so that the last level would have `(n-1)/2` nodes, thus `O(n)`. For the DFS, the space complexity will be given by the tree's maximum *height*. In the worst-case, the binary tree is skewed to the right so that we will have an implicit call stack of size `n`.
+
 
 // [#linkedlist-q-FILENAME]
 // include::content/part02/linked-list.asc[tag=linkedlist-q-FILENAME]

book/config

@@ -293,7 +293,7 @@ maxSubArray([-3, 4,-1, 2, 1, -5]); // 6 (sum [4,-1, 2, 1])
 maxSubArray([-2, 1, -3, 4, -1, 3, 1]); // 7 (sum [4,-1, 3, 1])
 ----
 
-_Seen in interviews at: Amazon, Apple, Google, Microsoft, Facebook_
+// _Seen in interviews at: Amazon, Apple, Google, Microsoft, Facebook_
 // end::array-q-max-subarray[]
 
 [source, javascript]
@@ -320,7 +320,7 @@ maxProfit([5, 10, 5, 10]) // 5 (buying at 5 and selling at 10)
 
 ----
 
-_Seen in interviews at: Amazon, Facebook, Bloomberg_
+// _Seen in interviews at: Amazon, Facebook, Bloomberg_
 // end::array-q-buy-sell-stock[]
 
 [source, javascript]

book/content/part02/array.asc

@@ -301,7 +301,7 @@ mergeTwoLists(2->3->4, 1->2); // 1->2->2->3->4
 mergeTwoLists(2->3->4,null); // 2->3->4
 ----
 
-_Seen in interviews at: Amazon, Adobe, Microsoft, Google_
+// _Seen in interviews at: Amazon, Adobe, Microsoft, Google_
 // end::linkedlist-q-merge-lists[]
 
 [source, javascript]
@@ -329,7 +329,7 @@ hasSameData(hello, hel->lo); // true
 hasSameData(he->ll->o, h->i); // false
 ----
 
-_Seen in interviews at: Facebook_
+// _Seen in interviews at: Facebook_
 // end::linkedlist-q-linkedlist-same-data[]
 
 [source, javascript]

book/content/part02/linked-list.asc

@@ -103,7 +103,7 @@ counter.request(3100); // 1 (last requests was 100 ms ago, > 10ms, so doesn't co
 counter.request(3105); // 2 (last requests was 5 ms ago, <= 10ms, so it counts)
 ----
 
-_Seen in interviews at: Google, Bloomberg, Yandex_
+// _Seen in interviews at: Google, Bloomberg, Yandex_
 // end::queue-q-recent-counter[]
 
 
@@ -135,7 +135,7 @@ expect(snakeGame.move('L')).toEqual(2); //  2 (ate food2)
 expect(snakeGame.move('U')).toEqual(-1); // -1 (hit wall)
 ----
 
-_Seen in interviews at: Amazon, Bloomberg, Apple_
+// _Seen in interviews at: Amazon, Bloomberg, Apple_
 // end::queue-q-design-snake-game[]
 
 [source, javascript]

book/content/part02/queue.asc

@@ -106,7 +106,7 @@ isParenthesesValid('[{]}'); // false (brakets are not closed in the right order)
 isParenthesesValid('([{)}]'); // false (closing is out of order)
 ----
 
-_Seen in interviews at: Amazon, Bloomberg, Facebook, Citadel_
+// _Seen in interviews at: Amazon, Bloomberg, Facebook, Citadel_
 // end::stack-q-valid-parentheses[]
 
 [source, javascript]
@@ -135,7 +135,7 @@ dailyTemperatures([30, 28, 50, 40, 30]); // [2 (to 50), 1 (to 28), 0, 0, 0]
 dailyTemperatures([73, 69, 72, 76, 73, 100]); // [3, 1, 1, 0, 1, 100]
 ----
 
-_Seen in interviews at: Amazon, Adobe, Cisco_
+// _Seen in interviews at: Amazon, Adobe, Cisco_
 // end::stack-q-daily-temperatures[]
 
 [source, javascript]

book/content/part02/stack.asc

@@ -92,3 +92,141 @@ If we have the following tree:
 ----
 
 Post-order traverval will return `3, 4, 5, 15, 40, 30, 10`.
+
+
+==== Practice Questions
+(((Interview Questions, Binary Tree)))
+
+
+// tag::binary-tree-q-diameter-of-binary-tree[]
+===== Binary Tree Diameter
+
+*BT-1*) _Find the diameter of a binary tree. A tree's diameter is the longest possible path from two nodes (it doesn't need to include the root). The length of a diameter is calculated by counting the number of edges on the path._
+
+// end::binary-tree-q-diameter-of-binary-tree[]
+
+// _Seen in interviews at: Facebook, Amazon, Google_
+
+// Example 1:
+// [graphviz, tree-diameter-example-1, png]
+// ....
+// graph G {
+//     1 -- 2 [color=red]
+//     1 -- 3 [color=red]
+
+//     2 -- 4
+//     2 -- 5 [color=red]
+// }
+// ....
+
+// Example 2:
+// [graphviz, tree-diameter-example-2, png]
+// ....
+// graph G {
+//     1
+//     2
+//     3
+//     4
+//     5
+//     6
+//     "null" [color=white, fontcolor = white]
+//     "null." [color=white, fontcolor = white]
+//     7
+//     8
+//     "null.." [color=white, fontcolor = white]
+//     "null..." [color=white, fontcolor = white]
+//     9
+
+//     1 -- 2
+//     1 -- 3
+
+//     3 -- 4 [color=red]
+//     3 -- 5 [color=red]
+
+//     4 -- 6 [color=red]
+//     4 -- "null." [color=white]
+
+//     5 -- "null" [color=white]
+//     5 -- 7 [color=red]
+
+//     6 -- 8 [color=red]
+//     6 -- "null.." [color=white]
+
+//     7 -- "null..." [color=white]
+//     7 -- 9 [color=red]
+// }
+// ....
+
+Examples:
+
+[source, javascript]
+----
+/*           1
+            / \
+           2   3
+          / \
+         4   5          */
+diameterOfBinaryTree(toBinaryTree([1,2,3,4,5])); // 3
+// For len 3, the path could be 3-1-2-5 or 3-1-2-4
+
+/*           1
+            / \
+           2   3
+              / \
+             4   5
+            /     \
+           6       7
+          /         \
+         8           9      */
+const array = [1,2,3,null,null,4,5,6,null,null,7,8,null,null,9];
+const tree = BinaryTreeNode.from(array);
+diameterOfBinaryTree(tree); // 6 (path: 8-6-4-3-5-7-9)
+----
+
+Starter code:
+
+[source, javascript]
+----
+include::../../interview-questions/diameter-of-binary-tree.js[tags=description;placeholder]
+----
+
+
+_Solution: <<binary-tree-q-diameter-of-binary-tree>>_
+
+
+
+
+// tag::binary-tree-q-binary-tree-right-side-view[]
+===== Binary Tree from right side view
+
+*BT-2*) _Imagine that you are viewing the tree from the right side. What nodes would you see?_
+
+// end::binary-tree-q-binary-tree-right-side-view[]
+
+// _Seen in interviews at: Facebook, Amazon, ByteDance (TikTok)._
+
+Examples:
+
+[source, javascript]
+----
+/*
+ 1      <- 1 (only node on level)
+ /   \
+2     3   <- 3 (3 is the rightmost)
+ \
+  4       <- 4 (only node on level) */
+rightSideView(BinaryTreeNode.from([1, 2, 3, null, 4])); // [1, 3, 4]
+
+rightSideView(BinaryTreeNode.from([])); // []
+rightSideView(BinaryTreeNode.from([1, 2, 3, null, 5, null, 4, 6])); // [1, 3, 4, 6]
+----
+
+Starter code:
+
+[source, javascript]
+----
+include::../../interview-questions/binary-tree-right-side-view.js[tags=description;placeholder]
+----
+
+_Solution: <<binary-tree-q-binary-tree-right-side-view>>_
+

book/content/part03/binary-search-tree-traversal.asc

@@ -12,7 +12,7 @@ A tree is a non-linear data structure where a node can have zero or more connect
 .Tree Data Structure: root node and descendants.
 image::image31.jpg[image,width=404,height=240]
 
-As you can see in the picture above, this data structure resembles an inverted tree hence the name. It starts with a *root* node and *branch* off with its descendants, and finally *leaves*.
+As you can see in the picture above, this data structure resembles an inverted tree, hence the name. It starts with a *root* node and *branch* off with its descendants, and finally *leaves*.
 
 ==== Implementing a Tree
 
@@ -54,17 +54,17 @@ image::image31.jpg[image]
 
 ==== Types of Binary Trees
 
-There are different kinds of trees depending on the restrictions. E.g. The trees that have two children or less are called *binary tree*, while trees with at most three children are called *Ternary Tree*. Since binary trees are most common we are going to cover them here and others in another chapter.
+There are different kinds of trees, depending on the restrictions. E.g. The trees with two children or less are called *binary tree*, while trees with at most three children are called *Ternary Tree*. Since binary trees are the most common, we will cover them here and others in another chapter.
 
 ===== Binary Tree
 (((Binary Tree)))
 (((Data Structures, Non-Linear, Binary Tree)))
-The binary restricts the nodes to have at most two children. Trees, in general, can have 3, 4, 23 or more, but not binary trees.
+The binary restricts the nodes to have at most two children. Trees can have 0, 1, 2, 7, or more, but not binary trees.
 
 .Binary tree has at most 2 children while non-binary trees can have more.
 image::image32.png[image,width=321,height=193]
 
-Binary trees are one of the most used kinds of tree, and they are used to build other data structures.
+Binary trees are one of the most used kinds of trees, and they are used to build other data structures.
 
 .Binary Tree Applications
 - <<part03-graph-data-structures#map>>
@@ -90,7 +90,7 @@ image::image33.png[image,width=348,height=189]
 (((Max-Heap)))
 (((Min-Heap)))
 (((Data Structures, Non-Linear, Binary Heap)))
-The heap (max-heap) is a type of binary tree where the parent's value is higher than the value of both children. Opposed to the BST, the left child doesn’t have to be smaller than the right child.
+The heap (max-heap) is a type of binary tree where the parent's value is higher than both children's value. Opposed to the BST, the left child doesn’t have to be smaller than the right child.
 
 .Heap vs BST
 image::image34.png[image,width=325,height=176]

book/content/part03/tree-intro.asc

@@ -0,0 +1,59 @@
+const { Queue } = require('../../src/index');
+
+// tag::description[]
+/**
+ * Find the rightmost nodes by level.
+ *
+ * @example
+ *     1      <- 1
+ *   /   \
+ *  2     3   <- 3
+ *   \
+ *    4       <- 4
+ *
+ * @param {BinaryTreeNode} root - The root of the binary tree.
+ * @returns {number[]} - array with the rightmost nodes values.
+ */
+function rightSideView(root) {
+  // end::description[]
+  // tag::placeholder[]
+  // write your code here...
+  // end::placeholder[]
+  // tag::solution[]
+  if (!root) return [];
+  const queue = new Queue([root]);
+  const ans = [];
+
+  while (queue.size) {
+    const { size } = queue;
+    for (let i = 0; i < size; i++) {
+      const node = queue.dequeue();
+      if (i === size - 1) ans.push(node.value);
+      if (node.left) queue.enqueue(node.left);
+      if (node.right) queue.enqueue(node.right);
+    }
+  }
+
+  return ans;
+  // end::solution[]
+  // tag::description[]
+}
+// end::description[]
+
+// tag::dfs[]
+function rightSideViewDfs(root) {
+  const ans = [];
+
+  const dfs = (node, level = 0) => {
+    if (!node) return;
+    if (level === ans.length) ans.push(node.value);
+    dfs(node.right, level + 1); // right side first!
+    dfs(node.left, level + 1);
+  };
+
+  dfs(root);
+  return ans;
+}
+// end::dfs[]
+
+module.exports = { rightSideView, rightSideViewDfs };

book/images/tree-diameter-example-1.png

@@ -0,0 +1,24 @@
+const { rightSideView, rightSideViewDfs } = require('./binary-tree-right-side-view');
+const { BinaryTreeNode } = require('../../src/index');
+
+[rightSideView, rightSideViewDfs].forEach((fn) => {
+  describe(`Binary Tree: ${fn.name}`, () => {
+    it('should work with null', () => {
+      const actual = null;
+      const expected = [];
+      expect(fn(actual)).toEqual(expected);
+    });
+
+    it('should work with small case', () => {
+      const actual = BinaryTreeNode.from([1, 2, 3, null, 4]);
+      const expected = [1, 3, 4];
+      expect(fn(actual)).toEqual(expected);
+    });
+
+    it('should work with other case', () => {
+      const actual = BinaryTreeNode.from([1, 2, 3, null, 5, null, 4, 6]);
+      const expected = [1, 3, 4, 6];
+      expect(fn(actual)).toEqual(expected);
+    });
+  });
+});

book/images/tree-diameter-example-2.png

@@ -0,0 +1,31 @@
+// tag::description[]
+/**
+ * Find the length of the binary tree diameter.
+ *
+ * @param {BinaryTreeNode | null} root - Binary Tree's root.
+ * @returns {number} tree's diameter (longest possible path on the tree)
+ */
+function diameterOfBinaryTree(root) {
+  // end::description[]
+  // tag::placeholder[]
+  // write your code here...
+  // end::placeholder[]
+  // tag::solution[]
+  let diameter = 0;
+
+  const height = (node) => {
+    if (!node) return 0;
+    const left = height(node.left);
+    const right = height(node.right);
+    diameter = Math.max(diameter, left + right);
+    return 1 + Math.max(left, right);
+  };
+
+  height(root);
+  return diameter;
+  // end::solution[]
+  // tag::description[]
+}
+// end::description[]
+
+module.exports = { diameterOfBinaryTree };

book/interview-questions/binary-tree-right-side-view.js

@@ -0,0 +1,14 @@
+const { diameterOfBinaryTree } = require('./diameter-of-binary-tree');
+const { BinaryTreeNode } = require('../../src/index');
+
+describe('Binary Tree: Diameter', () => {
+  it('should find the diameter', () => {
+    const actual = BinaryTreeNode.from([1, 2, 3, 4, 5]);
+    expect(diameterOfBinaryTree(actual)).toEqual(3);
+  });
+
+  it('should find the diameter when does not pass through the root node', () => {
+    const arr = [1, 2, 3, null, null, 4, 5, 6, null, null, 7, 8, null, null, 9];
+    expect(diameterOfBinaryTree(BinaryTreeNode.from(arr))).toEqual(6);
+  });
+});

book/interview-questions/binary-tree-right-side-view.spec.js

@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "test": "jest --verbose",
-    "watch": "jest --watch --verbose --coverage",
+    "watch": "jest --watch --coverage",
     "ci": "npx eslint src/ && jest --coverage",
     "coverage": "jest --coverage && open coverage/lcov-report/index.html",
     "coverage:win": "jest --coverage && cmd.exe /C start coverage/lcov-report/index.html",

book/interview-questions/diameter-of-binary-tree.js

@@ -172,6 +172,21 @@ class BinaryTreeNode {
     this.meta.data = value;
     return this;
   }
+
+  /**
+   * Convert Binary tree from an iterable (e.g. array)
+   * @param {array|string} iterable - The iterable
+   */
+  static from(iterable = []) {
+    const toBinaryTree = (array, index = 0) => {
+      if (index >= array.length) return null;
+      const node = new BinaryTreeNode(array[index]);
+      node.setLeftAndUpdateParent(toBinaryTree(array, index * 2 + 1));
+      node.setRightAndUpdateParent(toBinaryTree(array, index * 2 + 2));
+      return node;
+    };
+    return toBinaryTree(Array.from(iterable));
+  }
 }
 
 BinaryTreeNode.RIGHT = RIGHT;

book/interview-questions/diameter-of-binary-tree.spec.js

@@ -1,114 +1,167 @@
 const { BinaryTreeNode } = require('../../index');
 
+const { LEFT, RIGHT } = BinaryTreeNode;
+
 describe('Binary Tree Node', () => {
   let treeNode;
 
-  beforeEach(() => {
-    treeNode = new BinaryTreeNode('hola');
-  });
-
-  it('should start with null parent', () => {
-    expect(treeNode.parent).toBe(null);
-  });
-
-  it('should start with empty metadata', () => {
-    expect(treeNode.meta).toEqual({});
-  });
-
-  it('should hold a value', () => {
-    expect(treeNode.value).toBe('hola');
-  });
-
-  it('should have a height 0', () => {
-    expect(treeNode.height).toBe(0);
-  });
-
-  it('should set/get left node', () => {
-    expect(treeNode.left).toBe(null);
-    const newNode = new BinaryTreeNode(1);
-    treeNode.setLeftAndUpdateParent(newNode);
-    expect(treeNode.left.value).toBe(1);
-
-    expect(newNode.parent).toBe(treeNode);
-    expect(treeNode.height).toBe(1);
-    expect(treeNode.balanceFactor).toBe(1);
-  });
-
-  it('should set/get right node', () => {
-    expect(treeNode.right).toBe(null);
-    const newNode = new BinaryTreeNode(1);
-    treeNode.setRightAndUpdateParent(newNode);
-
-    expect(treeNode.right.value).toBe(1);
-    expect(newNode.parent).toBe(treeNode);
-    expect(treeNode.height).toBe(1);
-    expect(treeNode.balanceFactor).toBe(-1);
-  });
-
-  describe('Family operations', () => {
-    let g;
-    let p;
-    let u;
-    let c;
-    let s;
-
+  describe('with instance', () => {
     beforeEach(() => {
-      g = new BinaryTreeNode('grandparent');
-      p = new BinaryTreeNode('parent');
-      u = new BinaryTreeNode('uncle');
-      c = new BinaryTreeNode('child');
-      s = new BinaryTreeNode('sibling');
-
-      g.setRightAndUpdateParent(p);
-      g.setLeftAndUpdateParent(u);
-      p.setRightAndUpdateParent(c);
-      p.setLeftAndUpdateParent(s);
+      treeNode = new BinaryTreeNode('hola');
     });
 
-    it('should set heights', () => {
-      expect(g.height).toBe(2);
-      expect(g.balanceFactor).toBe(-1);
-
-      expect(p.height).toBe(1);
-      expect(p.balanceFactor).toBe(0);
+    it('should start with null parent', () => {
+      expect(treeNode.parent).toBe(null);
+    });
 
-      expect(u.height).toBe(0);
-      expect(u.balanceFactor).toBe(0);
+    it('should start with empty metadata', () => {
+      expect(treeNode.meta).toEqual({});
     });
 
-    it('should get the sibling', () => {
-      expect(c.sibling).toBe(s);
-      expect(p.sibling).toBe(u);
+    it('should hold a value', () => {
+      expect(treeNode.value).toBe('hola');
     });
 
-    it('should set leaf correctly', () => {
-      expect(c.isLeaf).toBe(true);
-      expect(u.isLeaf).toBe(true);
-      expect(p.isLeaf).toBe(false);
-      expect(g.isLeaf).toBe(false);
+    it('should have a height 0', () => {
+      expect(treeNode.height).toBe(0);
     });
 
-    it('should get null if no sibling', () => {
-      expect(g.sibling).toBe(null);
+    it('should set/get left node', () => {
+      expect(treeNode.left).toBe(null);
+      const newNode = new BinaryTreeNode(1);
+      treeNode.setLeftAndUpdateParent(newNode);
+      expect(treeNode.left.value).toBe(1);
+
+      expect(newNode.parent).toBe(treeNode);
+      expect(treeNode.height).toBe(1);
+      expect(treeNode.balanceFactor).toBe(1);
     });
 
-    it('should get the uncle', () => {
-      expect(c.uncle).toBe(u);
+    it('should set/get right node', () => {
+      expect(treeNode.right).toBe(null);
+      const newNode = new BinaryTreeNode(1);
+      treeNode.setRightAndUpdateParent(newNode);
+
+      expect(treeNode.right.value).toBe(1);
+      expect(newNode.parent).toBe(treeNode);
+      expect(treeNode.height).toBe(1);
+      expect(treeNode.balanceFactor).toBe(-1);
     });
 
-    it('should get null if no uncle', () => {
-      expect(g.uncle).toBe(null);
-      expect(p.uncle).toBe(null);
+    describe('Family operations', () => {
+      let g;
+      let p;
+      let u;
+      let c;
+      let s;
+
+      beforeEach(() => {
+        g = new BinaryTreeNode('grandparent');
+        p = new BinaryTreeNode('parent');
+        u = new BinaryTreeNode('uncle');
+        c = new BinaryTreeNode('child');
+        s = new BinaryTreeNode('sibling');
+
+        g.setRightAndUpdateParent(p);
+        g.setLeftAndUpdateParent(u);
+        p.setRightAndUpdateParent(c);
+        p.setLeftAndUpdateParent(s);
+      });
+
+      it('should set heights', () => {
+        expect(g.height).toBe(2);
+        expect(g.balanceFactor).toBe(-1);
+
+        expect(p.height).toBe(1);
+        expect(p.balanceFactor).toBe(0);
+
+        expect(u.height).toBe(0);
+        expect(u.balanceFactor).toBe(0);
+      });
+
+      it('should get the sibling', () => {
+        expect(c.sibling).toBe(s);
+        expect(p.sibling).toBe(u);
+      });
+
+      it('should set leaf correctly', () => {
+        expect(c.isLeaf).toBe(true);
+        expect(u.isLeaf).toBe(true);
+        expect(p.isLeaf).toBe(false);
+        expect(g.isLeaf).toBe(false);
+      });
+
+      it('should get null if no sibling', () => {
+        expect(g.sibling).toBe(null);
+      });
+
+      it('should get the uncle', () => {
+        expect(c.uncle).toBe(u);
+      });
+
+      it('should get null if no uncle', () => {
+        expect(g.uncle).toBe(null);
+        expect(p.uncle).toBe(null);
+      });
+
+      it('true if is parent left child', () => {
+        expect(s.isParentLeftChild).toBe(true);
+        expect(s.isParentRightChild).toBe(false);
+      });
+
+      it('true if is parent left child', () => {
+        expect(c.isParentLeftChild).toBe(false);
+        expect(c.isParentRightChild).toBe(true);
+      });
     });
+  });
 
-    it('true if is parent left child', () => {
-      expect(s.isParentLeftChild).toBe(true);
-      expect(s.isParentRightChild).toBe(false);
+  describe('with static methods', () => {
+    it('should work with null', () => {
+      const tree = BinaryTreeNode.from();
+      expect(tree).toEqual(null);
     });
 
-    it('true if is parent left child', () => {
-      expect(c.isParentLeftChild).toBe(false);
-      expect(c.isParentRightChild).toBe(true);
+    it('should build from array', () => {
+      /*
+                        0
+                       / \
+                      1   2
+                     / \   \
+                    3   5   4
+      */
+      const tree = BinaryTreeNode.from([0, 1, 2, 3, 5, null, 4]);
+      expect(tree.toValues()).toEqual({
+        value: 0,
+        left: 1,
+        right: 2,
+        parent: null,
+        parentSide: null,
+      });
+
+      expect(tree.left.toValues()).toEqual({
+        value: 1,
+        left: 3,
+        right: 5,
+        parent: 0,
+        parentSide: LEFT,
+      });
+
+      expect(tree.right.toValues()).toEqual({
+        value: 2,
+        left: null,
+        right: 4,
+        parent: 0,
+        parentSide: RIGHT,
+      });
+
+      expect(tree.right.right.toValues()).toEqual({
+        value: 4,
+        left: null,
+        right: null,
+        parent: 2,
+        parentSide: RIGHT,
+      });
     });
   });
 });