[WEEK 03] 추슬기

[doitchuu]

이렇게 풀었어요

1. Linked List Cycle

• 문제를 풀었어요.
• 풀이 시간 : 25분

1) 복잡도 계산

• 내 풀이(Set 방문 체크)
  • 시간 복잡도: O(n) (노드 한 번씩 방문)
  • 공간 복잡도: O(n) (방문한 노드를 Set에 저장)
• 다른 사람 풀이(slow/fast)
  • 시간 복잡도: O(n)
  • 공간 복잡도: O(1)

2) 접근 아이디어

핵심은 “값(val)이 반복되는지”가 아니라, 같은 노드(객체)를 다시 방문하는지였다.

내 풀이(Set)

1. 현재 노드부터 끝까지 순회한다.
2. 노드를 Set에 저장하면서 “이미 봤던 노드인지” 확인한다.
3. 이미 봤던 노드를 다시 만나면 순환 구조이므로 true를 반환한다.
4. 끝까지 가서 null이면 사이클이 없으므로 false 반환한다.

다른 풀이(slow/fast)

1. slow는 1칸, fast는 2칸씩 이동한다.
2. 사이클이 있으면 fast가 결국 slow를 따라잡아 같은 노드를 가리키는 순간이 생긴다.
3. fast가 null에 도달하면 사이클이 없다.

var hasCycle = function(head) {
    let fast = head;
    let slow = head;

    while (fast && fast.next) {
        fast = fast.next.next;
        slow = slow.next;

        if (fast === slow) {
            return true;
        }
    }

    return false;    
};

3) 회고

처음에 head가 배열처럼 보이는 입력(예: [3,2,0,-4])로 들어오는 줄 알고 혼란스러웠다.
실제로는 배열이 아니라 노드 객체(참조) head가 들어오고, 사이클 판단은 val이 아니라 노드 자체(cur)를 다시 만나는지가 핵심이었다.

• Set 방식은 직관적으로 이해가 쉬웠고 빠르게 구현할 수 있었다.
• slow/fast 방식은 처음엔 “마주칠 때까지 봐야 하잖아?” 싶었는데, 결국 둘 다 O(n)이고 **공간 O(1)**이라 더 좋은 정석 풀이로 느껴졌다.
• 다음부터 링크드리스트 문제는 “입력 배열 표기 = 설명용”이고 실제는 node.next로 따라가는 구조라는 걸 먼저 떠올리자.

2. Implement Queue using Stacks

• 문제를 풀었어요.
• 풀이 시간 : 70분 이상..?

1) 복잡도 계산

• 시간 복잡도: Amortized O(1)
  • push: O(1)
  • pop/peek: outStack이 비었을 때만 inStack → outStack으로 이동 (총 이동 횟수는 각 원소당 최대 1번)
• 공간 복잡도: O(n) (두 스택에 최대 n개 저장)

2) 접근 아이디어

처음엔 “배열을 큐처럼 쓰면 되지 않나?”로 접근해서 shift/unshift나 구조분해로 앞에서 꺼내는 방법을 시도했는데,
이 문제는 “스택 연산만 사용” 조건 때문에 그 방식이 틀렸다.

• inStack은 들어오는 곳(push)
• outStack은 나가는 곳(pop/peek)
• outStack이 비어 있을 때만 inStack의 모든 원소를 outStack으로 옮긴다(뒤집기)

push(x):
inStack.push(x)

pop():
if outStack 비었으면:
while inStack not empty:
outStack.push(inStack.pop())
return outStack.pop()

peek():
if outStack 비었으면:
while inStack not empty:
outStack.push(inStack.pop())
return outStack.top()

empty():
return inStack empty && outStack empty

3) 회고

시행착오 포인트가 명확했다.

• 처음 시도에서 shift/unshift(앞에서 빼기/넣기)를 썼는데, 이건 스택 연산이 아니라서 문제 조건 위반이었다.
• 스택에서 스택으로 옮기면 순서가 뒤집힌다.

이렇게 풀었어요

3. Lowest Common Ancestor of a Binary Search Tree

• 문제를 풀었어요.
• 풀이 시간 : X

1) 복잡도 계산

• 시간 복잡도: O(h)
  (h = 트리의 높이, 평균적으로 log n)
• 공간 복잡도: O(1)
  (반복문 사용, 추가 메모리 없음)

2) 접근 아이디어

🔹 문제 핵심

LCA는 p와 q를 모두 자손으로 가지는 가장 아래 노드이다.

BST의 성질을 이용하면 탐색 범위를 계속 줄일 수 있다.

BST 규칙:

• 왼쪽 서브트리 값 < root.val
• 오른쪽 서브트리 값 > root.val

🔹 사고 흐름

1. p와 q 중 작은 값(small), 큰 값(big)을 구한다.
2. 현재 root와 비교한다.
   • big < root.val → 둘 다 왼쪽에 있음 → root = root.left
   • small > root.val → 둘 다 오른쪽에 있음 → root = root.right
   • 그 외 → 현재 root가 LCA

3) 회고

처음에는 “최소/최대값을 구해서 root 위치를 바꿔야 할 것 같다”는 감은 있었지만, 그 생각을 코드로 연결하는 게 어려웠다.

핵심은:

• BST의 정렬 성질을 이용하면
• 매 단계마다 탐색 범위를 절반씩 줄일 수 있다는 점이었다.

“둘 다 왼쪽 / 둘 다 오른쪽 / 갈라지는 순간”
이 세 가지 경우만 정리하면 코드가 매우 단순해진다.

배운 점:

• 트리 문제는 구조를 먼저 문장으로 정리하면 코드로 옮기기 훨씬 쉬워진다.
• BST는 ‘값 비교 기반 분기 탐색’ 문제다.

4. Balanced Binary Tree

• 문제를 풀었어요.
• 풀이 시간 : X

1) 회고

해당 문제는 오늘 점심에 다시 풀어보려합니다. 문제 구현 자체를 못했어요 ㅠ

[sik9252]

pop과 peek에서 중복으로 사용되는 로직 분리해도 좋을것 같군용! 다른건 완벽!!

[raejun92]

BalancedBinaryTree 푸시면 다시 요청 주세요!

[raejun92]

저는 정렬이 되어 있는 줄 모르고 풀었는데 정렬되어 있는 걸 이용하면 됐군요!

[doitchuu]

4번 문제는 다시 풀어도 못풀어서 정답을 붙여뒀어요!
못푼 문제는 못풀었기 때문에 비워 적어둬야할 것 같아서
비워 적어두었었어요. 참고 부탁드려요!

[sik9252]

노트북을 안가져가서 늦게 검토했네요 죄송합니다ㅠㅠ 마지막에 확인했을때 BalancedBinaryTree 풀이만 안되어 있던걸로 기억하는데 한 번의 DFS에서 높이를 계산하면서, 불균형이면 -1을 반환해 위로 전파하는 방식인거죵??? 정석으로 잘 푸신것 같아요!