[hyunow] 24.11.19

[hyunow]

📌 푼 문제

문제이름	문제링크
Two Sum	https://leetcode.com/problems/two-sum
Maximum Depth of Binary Tree	https://leetcode.com/problems/maximum-depth-of-binary-tree
Linked List Cycle	https://leetcode.com/problems/linked-list-cycle
Happy Number	https://leetcode.com/problems/happy-number
Valid Parentheses	https://leetcode.com/problems/valid-parentheses

---

📝 간단한 풀이 과정

1. Two Sum

• 단순하게 이중 for문 활용해서 두개의 수를 더하면서 조건을 확인했습니다.

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const n = nums.length;
    const ans = [];

    for (let i = 0; i < n - 1; i++) {
        for (let j = i + 1; j < n; j++) {
            if (nums[i] + nums[j] === target) {
                ans.push(parseInt(i))
                ans.push(parseInt(j))
                return ans
            }
        }
    }
};

---

104. Maximum Depth of Binary Tree

• 왼쪽 트리 깊이와 오른쪽 트리 깊이를 재귀적으로 구하면서 null이 아니면 +1 을 해주면서 깊이를 추가합니다.
• root = null 인 경우는, 마지막 노드로 0을 리턴합니다. (탈출 조건)

/**
 * 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
    }
    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1
};

---

141. Linked List Cycle

• 한칸씩 이동하는 slow_pointer와 두칸씩 이동하는 fast_pointer 두개를 활용합니다.
• cycle이 생기면 slow_pointer와 fast_pointer가 동일해지는 순간이 존재하기 때문에 이를 활용합니다.

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    var slow_pointer = head
    var fast_pointer = head

    while(fast_pointer !== null && fast_pointer.next !== null) {
        slow_pointer = slow_pointer.next
        fast_pointer = fast_pointer.next.next
        if(slow_pointer === fast_pointer) {
            return true
        }
    }

    return false
};

---

20. Valid Parentheses

• stack을 활용해서 stack의 가장 윗부분 괄호와 s의 현재 괄호가 쌍이 맞는지 확인하고, 쌍이 맞으면 stack.pop을, 맞지 않으면 s의 현재 괄호를 stack에 추가해줍니다.
• if 문을 좀 멍청하게 쓴 것 같긴 합니다... ><

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    const stack = [];
    const n = s.length;
    for (let i = 0; i < n; i++) {
        if (!stack) {
            stack.push(s[i])
        } else {
            let temp = stack.pop()
            if( (temp === '(' && s[i] === ')') ||
                (temp === '{' && s[i] === '}') ||
                (temp === '[' && s[i] === ']') ) {
                    continue
            } else {
                stack.push(temp)
                stack.push(s[i])
            }
        }
    }
    console.log(stack)
    if(stack.length === 1) {
        return true
    } else {
        return false
    }
};

---

202. Happy Number

• set을 활용해서 이미 방문한 숫자를 확인하도록 했습니다.
• 각 자릿수 제곱의 합이 1이 아니면 set에 존재하는지 확인하고, 이미 존재하는 값이면 return false, 처음 보는 값이면 set에 추가해줍니다.

/**
 * @param {number} n
 * @return {boolean}
 */
var isHappy = function(n) {
    const seen = new Set()

    while(true) {
        let sum = 0
        while (n > 0) {
            const num = n % 10
            sum += num ** 2
            n = Math.floor(n / 10)
        }
    
        if(sum === 1) {
            return true
        }

        if(seen.has(sum)) {
            return false
        }
    
        seen.add(sum)
        n = sum
        
    }
    
};

---

[JooKangsan]

수고하셨습니다!

[JooKangsan]

수고하셨습니다!! 현재 작성된 코드의 시간복잡도가 O(n²)인데요 해시맵을 사용하면 시간복잡도를 O(n)으로 개선 가능할 것 같습니다!
알고리즘 가끔 보러 가는데요 https://github.com/trekhleb/javascript-algorithms/blob/master/README.ko-KR.md
이거 한국어로 변역도 되어있어서 참고 할만 할거에요!