Add subtree of another tree LC medium JS

Author: nwthomas

src/leetcode/medium/balanced-binary-tree/balancedBinaryTree.js renamed to src/leetcode/easy/balanced-binary-tree/balancedBinaryTree.js

@@ -2,6 +2,7 @@
 
 ## Table of Contents
 
+-   [Balanced Binary Tree](balanced-binary-tree)
 -   [Best Time to Buy and Sell Stock](best-time-to-buy-and-sell-stock)
 -   [Binary Tree Diameter](binary-tree-diameter)
 -   [Binary Search](binary-search)

src/leetcode/medium/balanced-binary-tree/balancedBinaryTree.test.js renamed to src/leetcode/easy/balanced-binary-tree/balancedBinaryTree.test.js

@@ -0,0 +1,82 @@
+/*
+https://leetcode.com/problems/subtree-of-another-tree
+
+Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.
+
+A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.
+
+Example 1:
+Input: root = [1,2,3,4,5], subRoot = [2,4,5]
+Output: true
+
+Example 2:
+Input: root = [1,2,3,4,5,null,null,6], subRoot = [2,4,5]
+Output: false
+
+Constraints:
+1 <= The number of nodes in both trees <= 100.
+-100 <= root.val, subRoot.val <= 100
+*/
+
+class TreeNode {
+    constructor(val = 0, left = null, right = null) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+const isSameTree = (node1, node2) => {
+    if (!node1 && !node2) {
+        return true;
+    } else if (!node1 || !node2) {
+        return false;
+    }
+
+    const hasSameVal = node1.val === node2.val;
+    if (!hasSameVal) {
+        return false;
+    }
+
+    const leftResult = isSameTree(node1.left, node2.left);
+    const rightResult = isSameTree(node1.right, node2.right);
+
+    return leftResult && rightResult;
+};
+
+const isSubtree = (root, subRoot) => {
+    if (!root) {
+        return !subRoot;
+    }
+    if (!subRoot) {
+        return !root;
+    }
+
+    const stack = [];
+    if (root) {
+        stack.push(root);
+    }
+
+    while (stack.length > 0) {
+        const currentNode = stack.pop();
+
+        if (currentNode.val === subRoot.val) {
+            const result = isSameTree(currentNode, subRoot);
+
+            if (result) {
+                return true;
+            }
+        }
+
+        if (currentNode.left) {
+            stack.push(currentNode.left);
+        }
+        if (currentNode.right) {
+            stack.push(currentNode.right);
+        }
+    }
+
+    return false;
+};
+
+module.exports = { isSubtree, TreeNode };

src/leetcode/easy/easy.md

@@ -0,0 +1,47 @@
+const { isSubtree, TreeNode } = require("./subtreeOfAnotherTree");
+
+describe("isSubtree", () => {
+    it("should return true if the subtree is found in the main tree", () => {
+        const root = new TreeNode(1);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+        root.left.left = new TreeNode(4);
+        root.left.right = new TreeNode(5);
+        const subRoot = new TreeNode(2);
+        subRoot.left = new TreeNode(4);
+        subRoot.right = new TreeNode(5);
+        expect(isSubtree(root, subRoot)).toBe(true);
+    });
+
+    it("should return false if the subtree is not found in the main tree", () => {
+        const root = new TreeNode(1);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+        root.left.left = new TreeNode(4);
+        root.left.right = new TreeNode(5);
+        const subRoot = new TreeNode(2);
+        subRoot.left = new TreeNode(4);
+        subRoot.right = new TreeNode(6);
+        expect(isSubtree(root, subRoot)).toBe(false);
+    });
+
+    it("should return false if the root tree is present but the subtree is not", () => {
+        const root = new TreeNode(1);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+        root.left.left = new TreeNode(4);
+        root.left.right = new TreeNode(5);
+        expect(isSubtree(root, undefined)).toBe(false);
+    });
+
+    it("should return false if the subtree is present but the root tree is not", () => {
+        const subRoot = new TreeNode(1);
+        subRoot.left = new TreeNode(2);
+        subRoot.right = new TreeNode(3);
+        expect(isSubtree(undefined, subRoot)).toBe(false);
+    });
+
+    it("should return true if both the root and subtree are empty", () => {
+        expect(isSubtree(undefined, undefined)).toBe(true);
+    });
+});

src/leetcode/easy/subtree-of-another-tree/subtreeOfAnotherTree.js

@@ -4,7 +4,6 @@
 
 -   [Add Two Numbers](add-two-numbers)
 -   [Alien Dictionary](alien-dictionary)
--   [Balanced Binary Tree](balanced-binary-tree)
 -   [Best Time to Buy and Sell Stock II](best-time-to-buy-and-sell-stock-ii)
 -   [Binary Tree Level Order Traversal](binary-tree-level-order-traversal)
 -   [Clone Graph](clone-graph)
@@ -72,6 +71,7 @@
 -   [Spiral Matrix](spiral-matrix)
 -   [Subsets](subsets)
 -   [Subsets II](subsets-ii)
+-   [Subtree of Another Tree](subtree-of-another-tree)
 -   [Target Sum](target-sum)
 -   [Time-Based Key Value Store](time-based-key-value-store)
 -   [Top K Frequent ELements](top-k-frequent-elements)