[oh-chaeyeon] 25.02.06 (#40)

* 배열 자르기 / 기초

* 배열 원소의 길이 / 기초

* 배열 회전시키기 / 기초

* 중복된 숫자 개수 / 기초

* 제일 작은 수 제거하기 / 중급

* 행렬의 덧셈 / 중급

* 나누어 떨어지는 숫자 배열 / 중급

* 행렬의 곱셈 / 심화

* 교점에 별 만들기 / 심화

* n^2 배열 자르기 / 심화

* String Reversal / 기초

* Control Z / 기초

* Hate English / 기초

* String Calculation / 기초

* Crane Game / 중급

* Valid Parentheses / 중급

* Dart Game / 중급

* Rotate Parentheses / 심화

* Stock Price / 심화

* Delivery Box / 심화

* 순서쌍의 개수 / 기초

* 점의 위치 구하기 / 기초

* 로그인 성공? / 기초

* 특이한 정렬 / 기초

* 카드 뭉치 / 중급

* 공원 산책  / 중급

* 햄버거 만들기 / 중급

* 모스부호1 / 기초

* A로 B만들기 / 기초

* 진로 순서 정하기 / 기초

* 등수 매기기 / 기초

* 완주하지 못한 선수 / 중급

* 포켓몬 / 중급

* 추억 점수 / 중급

* 할인 행사 / 심화

* 오픈채팅방 / 심화

* Maximum Depth of Binary Tree / 초급

* Binary Tree Inorder Traversal / 초급

* Same Tree / 초급

* Invert Binary Tree / 초급

* Binary Tree Level Order Traversal / 중급

* Validate Binary Search Tree / 중급

* Construct Binary Tree from Preorder and Inorder Traversal / 중급

* 이진 변환 반복하기 / 심화

* Binary Tree Maximum Path Sum / 심화

Author: oh-chaeyeon

oh-chaeyeon/5주차_트리/Binary_Tree_Inorder_Traversal.js

@@ -0,0 +1,23 @@
+/**
+ * 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 inorderTraversal = function (root) {
+  const result = [];
+  function traverse(node) {
+    if (!node) return;
+    traverse(node.left);
+    result.push(node.val);
+    traverse(node.right);
+  }
+  traverse(root);
+  return result;
+};

oh-chaeyeon/5주차_트리/Binary_Tree_Level_Order_Traversal.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+  const result = [];
+
+  function traverse(node, level) {
+    if (!node) return;
+    if (!result[level]) result[level] = [];
+    result[level].push(node.val);
+    traverse(node.left, level + 1);
+    traverse(node.right, level + 1);
+  }
+
+  traverse(root, 0);
+  return result;
+};

oh-chaeyeon/5주차_트리/Binary_Tree_Maximum_Path_Sum.js

@@ -0,0 +1,31 @@
+/**
+ * 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 maxPathSum = function (root) {
+  let maxSum = -Infinity;
+
+  function dfs(node) {
+    if (!node) return 0;
+
+    const left = Math.max(dfs(node.left), 0);
+    const right = Math.max(dfs(node.right), 0);
+
+    const currentSum = node.val + left + right;
+
+    maxSum = Math.max(maxSum, currentSum);
+
+    return node.val + Math.max(left, right);
+  }
+
+  dfs(root);
+  return maxSum;
+};

oh-chaeyeon/5주차_트리/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js

@@ -0,0 +1,38 @@
+/**
+ * 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 {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+var buildTree = function (preorder, inorder) {
+  const inorderMap = new Map();
+  inorder.forEach((val, idx) => inorderMap.set(val, idx));
+
+  function build(preStart, preEnd, inStart, inEnd) {
+    if (preStart > preEnd || inStart > inEnd) return null;
+
+    const rootVal = preorder[preStart];
+    const root = new TreeNode(rootVal);
+    const inRootIndex = inorderMap.get(rootVal);
+    const leftSize = inRootIndex - inStart;
+
+    root.left = build(
+      preStart + 1,
+      preStart + leftSize,
+      inStart,
+      inRootIndex - 1
+    );
+    root.right = build(preStart + leftSize + 1, preEnd, inRootIndex + 1, inEnd);
+
+    return root;
+  }
+
+  return build(0, preorder.length - 1, 0, inorder.length - 1);
+};

oh-chaeyeon/5주차_트리/Invert_Binary_Tree.js

@@ -0,0 +1,26 @@
+/**
+ * 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 {TreeNode}
+ */
+var invertTree = function (root) {
+  if (root === null) {
+    return null;
+  }
+
+  let temp = root.left;
+  root.left = root.right;
+  root.right = temp;
+
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+};

oh-chaeyeon/5주차_트리/Maximum_Depth_of_Binary_Tree.js

@@ -0,0 +1,22 @@
+/**
+ * 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 maxDepth = function (root) {
+  if (root === null) {
+    return 0;
+  }
+
+  let leftDepth = maxDepth(root.left);
+  let rightDepth = maxDepth(root.right);
+
+  return Math.max(leftDepth, rightDepth) + 1;
+};

oh-chaeyeon/5주차_트리/Same_Tree.js

@@ -0,0 +1,28 @@
+/**
+ * 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} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function (p, q) {
+  if (p === null && q === null) {
+    return true;
+  }
+
+  if (p === null || q === null) {
+    return false;
+  }
+
+  if (p.val !== q.val) {
+    return false;
+  }
+
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};

oh-chaeyeon/5주차_트리/Validate_Binary_Search_Tree.js

@@ -0,0 +1,24 @@
+/**
+ * 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 {boolean}
+ */
+var isValidBST = function (root) {
+  function validate(node, lower, upper) {
+    if (!node) return true;
+
+    const val = node.val;
+    if (val <= lower || val >= upper) return false;
+
+    return validate(node.left, lower, val) && validate(node.right, val, upper);
+  }
+
+  return validate(root, -Infinity, Infinity);
+};

oh-chaeyeon/5주차_트리/이진_변환_반복하기.js

@@ -0,0 +1,17 @@
+function solution(s) {
+  let count = 0;
+  let removed = 0;
+
+  while (s !== "1") {
+    const originalLength = s.length;
+    const newStr = s
+      .split("")
+      .filter((char) => char === "1")
+      .join("");
+    removed += originalLength - newStr.length;
+    s = newStr.length.toString(2);
+    count++;
+  }
+
+  return [count, removed];
+}