adding new solution to subtree-of-another-tree javascript problem

Author: salvillalon45

javascript/0572-subtree-of-another-tree.js

@@ -4,93 +4,135 @@
  * @param {TreeNode} subRoot
  * @return {boolean}
  */
-var isSubtree = function(root, subRoot) {
-    if (!root) return false
+var isSubtree = function (root, subRoot) {
+    if (!root) return false;
 
-    if (isSame(root, subRoot)) return true
+    if (isSame(root, subRoot)) return true;
 
-    const hasLeftTree = isSubtree(root.left, subRoot)
-    const hasRightTree = isSubtree(root.right, subRoot)
+    const hasLeftTree = isSubtree(root.left, subRoot);
+    const hasRightTree = isSubtree(root.right, subRoot);
 
-    return hasLeftTree || hasRightTree
+    return hasLeftTree || hasRightTree;
 };
 
 const isSame = (root, subRoot) => {
-    const hasReachedEnd = !(root && subRoot)
-    if (hasReachedEnd) return root === subRoot
+    const hasReachedEnd = !(root && subRoot);
+    if (hasReachedEnd) return root === subRoot;
 
-    const isMismatch = root.val !== subRoot.val
-    if (isMismatch) return false
+    const isMismatch = root.val !== subRoot.val;
+    if (isMismatch) return false;
 
-    const isLeftSame = isSame(root.left, subRoot.left)
-    const isRightSame = isSame(root.right, subRoot.right)
+    const isLeftSame = isSame(root.left, subRoot.left);
+    const isRightSame = isSame(root.right, subRoot.right);
 
-    return isLeftSame && isRightSame
-}
+    return isLeftSame && isRightSame;
+};
 
-const hash = (val) => require('crypto')
-    .createHash('md5')
-    .update(val)
-    .digest('hex')
+const hash = (val) =>
+    require('crypto').createHash('md5').update(val).digest('hex');
 
 const merkle = (root) => {
-    if (!root) return '#'
+    if (!root) return '#';
 
-    const { left, val, right } = root
+    const { left, val, right } = root;
 
-    const leftMerkle = merkle(left)
-    const rightMerkle = merkle(right)
+    const leftMerkle = merkle(left);
+    const rightMerkle = merkle(right);
 
-    const merkleVal = [ leftMerkle, val, rightMerkle ].join('')
-    const merkleHash = hash(merkleVal)
+    const merkleVal = [leftMerkle, val, rightMerkle].join('');
+    const merkleHash = hash(merkleVal);
 
-    root.merkle = merkleHash
+    root.merkle = merkleHash;
 
-    return root.merkle
-}
+    return root.merkle;
+};
 
 const search = (root, subRoot) => {
-    if (!root) return false
+    if (!root) return false;
 
-    const hasSamePath = root.merkle === subRoot.merkle
-    if (hasSamePath) return true
+    const hasSamePath = root.merkle === subRoot.merkle;
+    if (hasSamePath) return true;
 
-    const left = search(root.left, subRoot)
-    const right = search(root.right, subRoot)
+    const left = search(root.left, subRoot);
+    const right = search(root.right, subRoot);
 
-    return left || right
-}
+    return left || right;
+};
 
-var isSubtree = function(root, subRoot) {
-    [ root, subRoot ].forEach(merkle)
+var isSubtree = function (root, subRoot) {
+    [root, subRoot].forEach(merkle);
 
-    return search(root, subRoot)
-}
+    return search(root, subRoot);
+};
 
 const hashify = (root, hash, postOrderKey) => {
-    if (!root) return '#'
+    if (!root) return '#';
 
-    const left = hashify(root.left, hash, postOrderKey)
-    const right = hashify(root.right, hash, postOrderKey)
+    const left = hashify(root.left, hash, postOrderKey);
+    const right = hashify(root.right, hash, postOrderKey);
 
-    const key = [left, root.val, right].join('')
+    const key = [left, root.val, right].join('');
 
     if (!hash.has(key)) {
-        hash.set(key, postOrderKey[0])
-        postOrderKey[0]++
+        hash.set(key, postOrderKey[0]);
+        postOrderKey[0]++;
     }
 
-    return hash.get(key)
-}
+    return hash.get(key);
+};
 
-var isSubtree = function(root, subRoot, hash = new Map (), postOrderKey = [0]) {
-    hashify(root, hash, postOrderKey)
+var isSubtree = function (root, subRoot, hash = new Map(), postOrderKey = [0]) {
+    hashify(root, hash, postOrderKey);
 
     const hashKey = [
         hashify(subRoot.left, hash, postOrderKey),
         subRoot.val,
-        hashify(subRoot.right, hash, postOrderKey)
-    ].join('')
+        hashify(subRoot.right, hash, postOrderKey),
+    ].join('');
+
+    return hash.has(hashKey);
+};
 
-    return hash.has(hashKey)
-}
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * https://leetcode.com/problems/subtree-of-another-tree/
+ * @param {TreeNode} root
+ * @param {TreeNode} subRoot
+ * @return {boolean}
+ */
+var isSubtree = function (root, subRoot) {
+    if (!subRoot) {
+        return true;
+    } else if (!root) {
+        return false;
+    } else if (isSameTree(root, subRoot)) {
+        return true;
+    }
+
+    const leftResult = isSubtree(root.left, subRoot);
+    const rightResult = isSubtree(root.right, subRoot);
+
+    return leftResult || rightResult;
+};
+
+function isSameTree(root, subRoot) {
+    if (!root && !subRoot) {
+        return true;
+    } else if (!root || !subRoot) {
+        return false;
+    } else if (root.val !== subRoot.val) {
+        return false;
+    }
+
+    const leftRes = isSameTree(root.left, subRoot.left);
+    const rightRes = isSameTree(root.right, subRoot.right);
+
+    return leftRes && rightRes;
+}