Joo kangsan (#104)

* 150 / Evaluate Reverse Polish Notation / medium / 17m40s

* 203 / House Robber II / medium / 21m40s

* 102 / House Robber II / medium / 14m20s

* 572 / Subtree of Another Tree / medium / 24m

Author: JooKangsan

JooKangsan/9주차/102_Binary Tree_Level_Order_Traversal.js

@@ -0,0 +1,35 @@
+/**
+ * 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)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function(root) {
+  if (!root) return [];
+  
+  const result = [];
+  const queue = [root];
+  
+  while (queue.length > 0) {
+      const levelSize = queue.length;
+      const currentLevel = [];
+      
+      for (let i = 0; i < levelSize; i++) {
+          const node = queue.shift();
+          currentLevel.push(node.val);
+          
+          if (node.left) queue.push(node.left);
+          if (node.right) queue.push(node.right);
+      }
+      
+      result.push(currentLevel);
+  }
+  
+  return result;
+};

JooKangsan/9주차/150_Evaluate_Reverse_Polish_Notation.js

@@ -0,0 +1,38 @@
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+var evalRPN = function (tokens) {
+  while (tokens.length > 1) {
+    for (let i = 0; i < tokens.length; i++) {
+      if (["+", "-", "*", "/"].includes(tokens[i])) {
+        const num1 = Number(tokens[i - 2]);
+        const num2 = Number(tokens[i - 1]);
+        const operator = tokens[i];
+        let result;
+
+        switch (operator) {
+          case "+":
+            result = num1 + num2;
+            break;
+          case "-":
+            result = num1 - num2;
+            break;
+          case "*":
+            result = num1 * num2;
+            break;
+          case "/":
+            result =
+              num1 / num2 > 0
+                ? Math.floor(num1 / num2)
+                : Math.ceil(num1 / num2);
+            break;
+        }
+
+        tokens.splice(i - 2, 3, result.toString());
+        break;
+      }
+    }
+  }
+  return Number(tokens[0]);
+};

JooKangsan/9주차/203_House_Robber_II.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  let n = nums.length;
+  if (n === 0) return 0;
+  if (n === 1) return nums[0];
+  if (n === 2) return Math.max(nums[0], nums[1]);
+
+  let firstCase = [...nums];
+  firstCase.pop();
+  let first = robHelper(firstCase);
+
+  let secondCase = [...nums];
+  secondCase.shift();
+  let second = robHelper(secondCase);
+
+  return Math.max(first, second);
+};
+
+function robHelper(houses) {
+  let n = houses.length;
+  let dp = new Array(n).fill(0);
+  dp[0] = houses[0];
+  dp[1] = Math.max(houses[0], houses[1]);
+
+  for (let i = 2; i < n; i++) {
+    dp[i] = Math.max(dp[i - 1], dp[i - 2] + houses[i]);
+  }
+  return dp[n - 1];
+}

JooKangsan/9주차/572_Subtree_of_Another_Tree.js

@@ -0,0 +1,29 @@
+/**
+ * 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)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} subRoot
+ * @return {boolean}
+ */
+var isSubtree = function(root, subRoot) {
+  if (!subRoot) return true;
+  if (!root) return false;
+  
+  const isSameTree = (tree1, tree2) => {
+      if (!tree1 && !tree2) return true;
+      if (!tree1 || !tree2) return false;
+      if (tree1.val !== tree2.val) return false;
+      return isSameTree(tree1.left, tree2.left) && 
+             isSameTree(tree1.right, tree2.right);
+  };
+  
+  return isSameTree(root, subRoot) || 
+         isSubtree(root.left, subRoot) || 
+         isSubtree(root.right, subRoot);
+};