minor: fixed bug in README for Arrays

Author: santhoshvai

00_Arrays/README.md

@@ -24,7 +24,7 @@
 
 12. Say you have an array for which the ith element is the price of a given stock on day i. If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit. - **[best-time-to-buy-and-sell-stock](best-time-to-buy-and-sell-stock)**
 
-13. Given an integer array nums, find the contiguous subarray within an array which has the largest product. *[maximum-product-subarray](maximum-product-subarray)**
+13. Given an integer array nums, find the contiguous subarray within an array which has the largest product. **[maximum-product-subarray](maximum-product-subarray)**
 
 ## Intervals
 

04_Trees_and_Graphs/README.md

@@ -18,6 +18,7 @@
 15. Write a function to find the total number of leaf nodes in a binary tree. **[countTheLeaves](countTheLeaves)**
 16. Given a binary tree, find its maximum depth. **[maximum-depth-of-binary-tree](maximum-depth-of-binary-tree)**
 17. Invert Binary Tree **[invert-binary-tree](invert-binary-tree)**
+18. Given two non-empty binary trees `s` and `t`, check whether tree `t` has exactly the same structure and node values with a subtree of `s` **[subtree-of-another-tree](subtree-of-another-tree)**
 
 > Questions 8, 16, 17 are part of [Team Blind's curated list](https://github.com/AlgorithmCrackers/Interview-Questions/issues/28)
 

04_Trees_and_Graphs/isBST/README.md

@@ -1,11 +1,45 @@
-**Write a program to verify whether the given tree is a binary search tree.**
+# Validate Binary Search Tree
 
-## Recursive solution
+![Difficulty-Medium](https://img.shields.io/badge/Difficulty-Medium-yellow)
 
-For each node,
-  - check if it satisfies min/max constraint
-  - Check recursively for its left and right subtrees
-    - For left subtree, the node's data is its max
-    - For right subtree, the node's data is its min
+Given a binary tree, determine if it is a valid binary search tree (BST).
 
-Time complexity - `O(n)`
+Assume a BST is defined as follows:
+
+The left subtree of a node contains only nodes with keys less than the node's key.
+The right subtree of a node contains only nodes with keys greater than the node's key.
+Both the left and right subtrees must also be binary search trees.
+
+
+## Example 1:
+
+```
+    2
+   / \
+  1   3
+
+Input: [2,1,3]
+Output: true
+```
+
+## Example 2:
+
+```
+    5
+   / \
+  1   4
+     / \
+    3   6
+
+Input: [5,1,4,null,null,3,6]
+Output: false
+Explanation: The root node's value is 5 but its right child's value is 4.
+```
+
+## Complexity Analysis (recursion based solution):
+
+- **Time complexity** : `O(n)`. We visit each node in the tree exactly once.
+
+- **Space complexity** : `O(log(n)) - best, o(n) worst`. The best case is for a completely balanced tree. The worst case is for an unbalanced tree. The space is to keep a recursion stack.
+
+#### [LeetCode link](https://leetcode.com/problems/validate-binary-search-tree/)

04_Trees_and_Graphs/isBST/solution.js

@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+
+/* Recursion based solution */
+var isValid = (node, min, max) => {
+  if (!node) return true
+  // if constraint is not satisified return false
+  if (!(node.val > min && node.val < max)) return false;
+  return isValid(node.left, min, node.val) && isValid(node.right, node.val, max)
+}
+
+var isValidBST = function(root) {
+  return isValid(root, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)
+};
+
+/*
+  NOTE: in JS NUMBER.MIN_VALUE is the value closest to 0, not the negative minimum
+*/

04_Trees_and_Graphs/subtree-of-another-tree/README.md

@@ -0,0 +1,61 @@
+# Subtree of Another Tree
+
+#### Difficulty in LeetCode
+![Difficulty-Easy](https://img.shields.io/badge/Difficulty-Easy-green)
+
+#### Difficulty of understanding complexity
+![Difficulty-Medium](https://img.shields.io/badge/Difficulty-Medium-yellow)
+
+Given two non-empty binary trees `s` and `t`, check whether tree t has exactly the same structure and node values with a subtree of `s`. A subtree of `s` is a tree consists of a node in `s` and all of this node's descendants. The tree `s` could also be considered as a subtree of itself.
+
+
+## Example 1:
+
+```
+Given tree s:
+
+     3
+    / \
+   4   5
+  / \
+ 1   2
+Given tree t:
+   4
+  / \
+ 1   2
+Return true, because t has the same structure and node values with a subtree of s.
+```
+
+## Example 2:
+
+```
+Given tree s:
+
+     3
+    / \
+   4   5
+  / \
+ 1   2
+    /
+   0
+Given tree t:
+   4
+  / \
+ 1   2
+Return false.
+```
+
+## Complexity Analysis (Recursive Comparision Approach):
+
+- **Time complexity** : `O(m * n)`. Where `n` is number of nodes in **s** and `m` is number of nodes in **t**.
+
+An alternative approach is to search through the larger tree, Tl , Each time a node in Tl matches the root of T2, call `isSameTree`. The matchTree method will compare the two subtrees to see if they are identical. Analyzing the runtime is somewhat complex. A naive answer would be to say that it is 0(nm) time, where n is the number of nodes in Tl and m is the number of nodes in T2. While this is technically correct, a little more thought can produce a tighter bound
+
+
+   * I think it's because in the worst case, the `isSameTree` method is called for each node. The `isSameTree` method will be O(n) with `n` being the size of the smaller tree. You are calling this `m` times with m being the size of the larger tree, so O(m)O(n) = O(mn)
+   * If the every element in the bigger tree contains same elements as the smaller tree, each time we need to compare until we find that the smaller tree reaches null but bigger tree's branch not. This process is persistence among all of the tree, so it would be m times n
+   * For Approach#2 O(mn) is definitely overestimating. The upper bound is closer to O(m + kn) where k is the number of nodes for which the root of t matches the value of the node of s that's just being traversed. To prove this point let's rewrite the traverse method slightly differently and add s.val == t.val && before the equals(s, t) call. Now it's clearer that equals is doing work only when the root of t matches the current node of s. How much work will it do? If the 2 trees match, it will do O(n) work. Otherwise, on any mismatch we'll break early so even O(m + k*n) is an over estimate.
+      * It's more complicated than that. If all n nodes match the root of the t, then traverse will no longer do O(n) work, unless t itself is also equal to all the same values. But then, it will only do that O(n) work once because of the ||. CTCI solution discusses this problem a little more in depth and looks at the runtime in a probabilistic fashion and proves this point.
+- **Space complexity** : `O(log(n)) - best, o(n) worst`. The best case is for a completely balanced tree. The worst case is for an unbalanced tree. The space is to keep a recursion stack. `n` is number of nodes in **s**.
+
+#### [LeetCode link](https://leetcode.com/problems/subtree-of-another-tree/)

04_Trees_and_Graphs/subtree-of-another-tree/solution.js

@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} s
+ * @param {TreeNode} t
+ * @return {boolean}
+ */
+var isSameTree = (r, t) => {
+  if (!r || !t) return r === t
+  return r.val === t.val && isSameTree(r.left, t.left) && isSameTree(r.right, t.right)
+}
+
+var isSubtree = function(s, t) {
+  return s !== null && (isSameTree(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t))
+};