[WEEK06-1] 추슬기

doitchuu/AddBinary.js

@@ -0,0 +1,23 @@
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {string}
+ */
+var addBinary = function(a, b) {
+    let i = a.length - 1;
+    let j = b.length - 1;
+    let carry = 0;
+    let result = "";
+
+    while (i >= 0 || j >= 0 || carry) {
+        let sum = carry;
+
+        if (i >= 0) sum += Number(a[i--]);
+        if (j >= 0) sum += Number(b[j--]);
+
+        result = String(sum % 2) + result;
+        carry =  Math.floor(sum / 2);
+    }
+
+    return result;
+};

doitchuu/DiameterOfBinaryTree.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
+ * @return {number}
+ */
+var diameterOfBinaryTree = function(root) {
+    let diameter = 0;
+
+    function dfs(node) {
+        if (node === null) return 0;
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        diameter = Math.max(diameter, left + right);
+
+        return Math.max(left, right) + 1;
+    }
+
+    dfs(root);
+    return diameter;
+};

doitchuu/MajorityElement.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var majorityElement = function(nums) {
+    // 배열엔 항상 다수의 원소가 존재한다.
+    // 다만, n / 2개 이상인 다수의 원소를 반환한다.
+    const map = new Map();
+    const majorElement = [];
+
+    for (let i = 0; i < nums.length; i++) {
+        map.set(nums[i], (map.get(nums[i]) || 0) + 1);
+
+        if (map.get(nums[i]) > nums.length / 2) {
+            return nums[i];
+        }
+    }
+};

doitchuu/MaximumDepthOfBinaryTree.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 maxDepth = function(root) {
+    function dfs(node) {
+        if (!node) {
+            return 0;
+        }
+
+        const left = dfs(node.left);
+        const right = dfs(node.right);
+
+        return Math.max(left, right) + 1;
+    }
+
+    return dfs(root);
+};

doitchuu/MiddleOfTheLinkedList.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var middleNode = function(head) {
+    let index = 1;
+    let current = head;
+    const map = new Map();
+
+    while (current) {
+        map.set(index, current);
+        current = current.next;
+        index++;
+    }
+
+    map.set(index, current);
+
+    let middle = Math.ceil(map.size / 2);
+
+    return map.get(middle);
+};

doitchuu/ReverseLinkedList.js

@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function(head) {
+    let prev = null;
+    let current = head;
+
+    while (current) {
+        let next = current.next;
+        current.next = prev;
+        prev = current;
+        current = next;
+    }
+    return prev;                                  
+};