๋งํฌ๋ ๋ฆฌ์คํธ๋?
ํฌ์ธํฐ๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ์ปฌ๋ ์ ์ด๋ผ๊ณ ํ ์ ์๊ณ , ์คํ, ํ, ํด์ ํ ์ด๋ธ์ ๊ตฌํํ๋๋ฐ ์ฌ์ฉ๋ ์ ์๋ค. ์์ ์ง์ ์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๋ ๊ฒ์ O(1) ์์ ์๊ฐ์ด ์์๋๋ค.

๋ ธ๋ ํด๋์ค ์ฝ๋ ์์
public class Node {
int val;
Node next;
ListNode() {}
Node(int val) {
this.val = val;
}
Node(int val, Node next) {
this.val = val;
this.next = next;
}
}
์ฝ๋ฉํ ์คํธ ํ ๐๏ธ
Recursion๋ ์์์ผ ํ๊ณ ๊ทธ ์ด๋ ต๋ค๋ ํฌ์ธํฐ๋ฅผ ํ์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฆผ์ ๋ง์ด ๊ทธ๋ ค๋ณด๋ฉด์ ์ฝ๋๋ฅผ ๋ฐ๋ผ๊ฐ ๋ณด๋ ๊ฒ์ด ์ค์ํ๋ค. ๋ง์ฝ Easy ๋ฌธ์ ๋ ๋๋ฌด ์ด๋ ต๊ฒ ๋๊ปด์ง๋ค๋ฉด ์ฌ๊ท๋ ๋ค๋ฅธ ๋ฌธ์ ๋ค์ ํ๋ฉด์ ์๊ฐ์ด ์ข ์ง๋ ๋ค์์ ๋ณด๋ฉด ์ดํด๊ฐ ๋ ์ ๋ ์๋ ์์ผ๋ ๋งํ๋ฉด ์ ๊น ์ฌ์๋ค ๊ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
Runner Technique
๐ ๋งํฌ๋ ๋ฆฌ์คํธ ๋ฌธ์ ์์ ๋ง์ด ํ์ฉ
๐ slow and fast pointer
Recursion
๐ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ, Space Complexity๋ O(n) ์ธ๋ฐ
๐ ์ฌ๊ธฐ์ n์ ์ฌ๊ท์ ๊น์ด๋ฅผ ๋ปํ๋ค
์ฝ๋
๐ง slow/fast ํฌ์ธํฐ ์ฌ์ฉ ์ while๋ฌธ ์กฐ๊ฑด ์์ฑ๋ฒ
slow, fast ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํธ๋ ๊ฒฝ์ฐ, ์๋ฅผ ๋ค์ด ๋ฆฌํธ์ฝ๋ 141๋ฒ ๋ฌธ์ Linked List Cycle์ slow ํฌ์ธํฐ๋ฅผ ํ์นธ์ฉ, fast ํฌ์ธํฐ๋ฅผ ๋์นธ์ฉ ์ฎ๊ธฐ๋ค๊ฐ ๋์ด ๋ง๋๋ฉด ํด๋น ๋งํฌ๋ ๋ฆฌ์คํธ์ ์ธ์ดํด์ด ์๋ค๊ณ ์ ์ ์๋๋ฐ ์ด๋ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.

์ฌ๊ธฐ์ while๋ฌธ์ fast๊ฐ null์ด ์๋๋ ๊ทธ๋ฆฌ๊ณ fast.next๊ฐ null์ด ์๋๋๋ฅผ break ์กฐ๊ฑด์ผ๋ก ์์ฑํด ์ค์ผํ๋ค. ์๋๋ฉด ์ธ์ดํด์ด ์๋ linearํ ๋งํฌ๋ ๋ฆฌ์คํธ์ผ ๊ฒฝ์ฐ์๋ while loop์ ๋น ์ ธ๋์์ผ ํ๋๋ฐ ์ด๋ ๋งํฌ๋ ๋ฆฌ์คํธ์ ๋ ธ๋์ ๊ฐฏ์๊ฐ ํ์์ผ๋์ ์ง์์ผ๋๋ฅผ ๊ณ ๋ คํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.

ํ์นธ์ฉ ์์ง์ด๋ slow๋ณด๋ค fast๊ฐ ํญ์ ๋ ์์ ๊ฐ๊ธฐ ๋๋ฌธ์ fast ํฌ์ธํฐ๋ฅผ ํ์ธํด์ผ ํ๊ณ ๊ทธ๋ฆผ์์์ ๊ฐ์ด ์ง์์ผ ๊ฒฝ์ฐ๋ fast ํฌ์ธํฐ๊ฐ null์ด ๋์ง๋ง ํ์์ผ ๊ฒฝ์ฐ์๋ fast.next๊ฐ null์ธ์ง๋ฅผ ํ์ธํด์ผ NullPointerException ์๋ฌ ์์ด ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ์ํํ ์ ์๋ค.
๐ง Reverse Linked List
Linked list๋ฅผ reverseํ๋ ค๋ฉด ๊ฒฐ๊ตญ ๊ธฐ์กด ๋ ธ๋์ next๊ฐ ๋ค์ ๋ ธ๋๊ฐ ์๋๋ผ ์ด์ ๋ ธ๋๋ฅผ ๊ฐ๋ฅดํค๋๋ก ๋ฐ๊ฟ์ค์ผ ํ๊ณ recursive, iterative ๋ฐฉ๋ฒ ๋๊ฐ์ง๋ก ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค.
Recursive ๋ฐฉ๋ฒ
1. base case: ๋งํฌ๋ ๋ฆฌ์คํธ๊ฐ empty๊ฑฐ๋ ํ๊ฐ์ ๋ ธ๋๋ง ๊ฐ์ง๊ณ ์๋ค๋ฉด ์ด๋ฏธ reversed ๋ ์ํ์์ผ๋ก head๋ฅผ ๋ฆฌํด
2. base case๊ฐ ์๋๋ฉด ์ฌ๊ท์ ์ผ๋ก reverse linked list ํจ์ ํธ์ถ (reverseList(head.next))
3. ์๋ก์ด ํค๋์ ๋ํ ์ฐธ์กฐ ์ ์ฅ (ListNode newHead = reverseList(head.next))
4. reverse linked list (head.next.next = head)
5. ์ํ์ฐธ์กฐ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ค์ ํฌ์ธํฐ์ ์ฐ๊ฒฐ์ ๋๋ก ๋์ด์ค (head.next = null)
6. ์๋ก์ด ํค๋ ๋ฆฌํด (return newHead)


reverse linked listํ๋ ๋ถ๋ถ์ธ head.next.next = head๊ฐ ์ดํด๊ฐ ์ ์๋๋ฉด, head.next๋ฅผ ์ค๊ฐ์ ํ๋ฒ front ๋ณ์๋ก ์ ์ฅํ๊ณ front์ ๋ค์์ด head๋ฅผ ๊ฐ๋ฅดํฌ ์ ์๊ฒ ์์ฑํ ์๋ ์๋ค.

Iterative ๋ฐฉ๋ฒ
1. temp ํฌ์ธํฐ๋ฅผ ์ ์ธํ ๋ค head์ ์์นํด์ ๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ ์ํํ๋๋ฐ ์ฌ์ฉ
2. prev ํฌ์ธํฐ๋ฅผ null๋ก ์์ฑํ ๋ค์ ์ด์ ๋ ธ๋๋ฅผ ํธ๋ํ๋๋ฐ ํ์ฉ. next ํฌ์ธ์ ๋ฐฉํฅ์ ๋ฐ๊พธ๋๋ฐ ์ฌ์ฉ
3. temp ํฌ์ธํฐ๋ฅผ ์ด๋ํ๋ฉด์ ๋งํฌ๋ ๋ฆฌ์คํธ ์ ์ฒด๋ฅผ ์ํ. temp ํฌ์ธํฐ๊ฐ null์ผ ๊ฒฝ์ฐ ์ํ ์ข ๋ฃ
4. temp ํฌ์ธํฐ๊ฐ ๋ค์์ผ๋ก ์ด๋ํ ๋ ธ๋์ ์ฐธ์กฐ๋ฅผ ์์ง ์๊ธฐ ์ํด temp.next๋ฅผ ์์ ํ๊ธฐ ์ ์ front ํฌ์ธํฐ์ ์ ์ฅ
5. temp ํฌ์ธํฐ๊ฐ prev๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ์์
----- next iteration์ ์ํํ๊ธฐ ์ํด prev, temp ์์น๋ฅผ ํ์นธ์ฉ ์ด๋ ----
6. prev๋ฅผ ํ์ฌ ๋ ธ๋๋ก ์ด๋
7. temp ํฌ์ธํฐ๋ฅผ front ํฌ์ธํฐ๋ก ์ด๋
8. temp๊ฐ ๋์ด ๋๋ฉด reversed linked list์ ์๋ก์ด head์ธ prev ํฌ์ธํฐ ๋ฆฌํด

๋งํฌ๋ ๋ฆฌ์คํธ ๋ฌธ์
LeetCode
206. Reverse Linked List (iterativeํ๊ณ recursive ๋ฐฉ๋ฒ ๋๊ฐ์ง๋ก ํ์ด๋ด์ผํจ)
876. Middle of the Linked List (fast and slow pointer ํ์ฉ. Tortoise and Hare ์๊ณ ๋ฆฌ์ฆ)
21.Merge Two Sorted Lists (์ด๊ฒ๋ iterative/recursive ๋ฐฉ๋ฒ ๋๊ฐ์ง๋ก ํ์ด๋ด์ผ ํ๊ณ ์ด๋ฏธ ์ ๋ ฌ์ด ๋์ด ์๊ธฐ ๋๋ฌธ์ ํฌํฌ์ธํฐ ๊ฐ๋ ์ ํ์ฉํด์ ๋จธ์งํ๋ฉด ๋ ๊ฒ ๊ฐ์ง๋ง next pointer๋ฅผ ๋ณ๊ฒฝํด์ค์ผ ํด์ Easy ๋ฌธ์ ์ด์ง๋ง ์๊ฐ๋ณด๋ค ์ด๋ ค์ โ โ โ )
19. Remove Nth Node From End of List (fast/slow pointer ํ์ฉ. fast ํฌ์ธํฐ๋ฅผ n ๋ ธ๋ ์์ ์์นํ ๋ค์ slow/fast ํฌ์ธํฐ๋ฅผ 1์ฉ ์์ง์ด๋ฉด, fast ํฌ์ธํฐ๊ฐ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ธ๋์ ์์ ๋ slow ํฌ์ธํฐ๋ ๋ง์ง๋ง ๋ ธ๋์์ nth๋ ธ๋ ์์ ์์น)
2. Add Two Numbers (๋ง์ฝ์ ์๋ก์ด ๋ ธ๋ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค๋ฉด dummy node ํ์ฉํ๋ฉด ์ฝ๋๊ฐ ๊น๋ํด์ง. int carry ๋ณ์๋ฅผ ์ ์ธํด์ 10 ์ ๋ณด ์ ์ฅ)
237. Delete Node in a Linked List (๋ฌธ์ ์ค๋ช ์ด ๋ช ํํ์ง ์์ ์ ์๋๋ฐ ๋ฆฌํธ์ฝ๋ ๋์ค์ปค์ ์ Best๋ก ์ ๋ ฌํ์ ๋ ๋์ค๋ ๋งจ ์ฒ์ ๊ธ์ ์ฐธ๊ณ ํ๋ฉด ์ธ์ฌ์ดํธ๋ฅผ ์ป์ ์ ์์. "no one can delete the node correctly without access to its predecessor")
160. Intersection of Two Linked Lists (๋ฆฌ์คํธ์ ๊ธธ์ด๋ฅผ ๊ตฌํด์ ํ ์๋ ์์ง๋ง ๋๊ฐ์ ๋๋ฏธ ๋ ธ๋๋ฅผ ํค๋์ ์์นํ ๋ค์ ๋ฆฌ์คํธ ์ํ. null์ผ ๋ ํด๋น ๋ ธ๋๋ฅผ ๋ฐ๋ ๋ฆฌ์คํธ์ ํค๋์ ์์นํ ๋ค์ ๋๊ฐ์ ๋๋ฏธ ๋ ธ๋๊ฐ ๋ง๋ ๋๊น์ง ์ํ)
141. Linked List Cycle (slow/fast ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฌธ์ )
25. Reverse Nodes in k-Group (๋งํฌ๋ ๋ฆฌ์คํธ๋ฅผ reverse ํ๋ ๋ฐฉ๋ฒ, ์ฌ๊ท๋ฅผ ์๊ณ ์์ด์ผ ํ ์ ์์ โ โ โ โ )
234. Palindrome Linked List (์ค๊ฐ ๋ ธ๋๋ฅผ ์ฐพ์์ ๋๋ฒ์งธ ๋ถ๋ถ์ reverse. ํฌ์ธํฐ์ ์์น๊ฐ ํท๊ฐ๋ฆด ์ ์์ผ๋ฏ๋ก ๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ ค๋ด์ผํจ)
142. Linked List Cycle 2 (141๋ฒ์ ์ฌํ ๋ฒ์ . ์ฐ์ cycle์ด ์๋์ง ์ฐพ๊ณ , slowํฌ์ธํฐ๋ starting point์, fast ํฌ์ธํฐ๋ collision point์ ์์นํ ๋ค ํ๊ฐ์ฉ ์ด๋ํ๋ค๊ฐ ๋์ด ๋ง๋๋ ๊ณณ์ด starting ํฌ์ธํธ์ธ๋ฐ ์ด๊ฒ์ ๋ํ ์ค๋ช ์ takeUForward ๋์์์ ์ ๋์์์)
61. Rotate List (๋ฐฐ์ด๋ฌธ์ ์์๋ ๊ทธ๋ ์ง๋ง k๋ฒ์ rotateํ๋ผ๋ ๋ฌธ์ ๊ฐ ๋์ค๋ฉด % modulo๋ฅผ ์ฌ์ฉํด์ผํจ. ์ด ๋ฌธ์ ์์๋ recursion๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ k๋ฒ ํ์ ํ๋ฉด StackOverflowError๊ฐ ๋ธ)
138. Copy List with Random Pointer (deep copyํด์ผํจ. ํด์๋งต์ ์ฌ์ฉํด์ ํ์ด๋ ๋๋๋ฐ Space Complexity๋ฅผ O(1)๋ก ์ค์ด๋ ค๋ฉด ์๋ก ๋ง๋ ๋ ธ๋๋ฅผ ๊ธฐ์กด ๋ ธ๋ ๋ฆฌ์คํธ ์์ ์ฌ์ด์ฌ์ด์ ์์นํด์ ํ ์ ์์)
1171. Remove Zero Sum Consecutive Nodes from Linked List (prefix sum๊ณผ hashmap ์ฌ์ฉ)
์ฐธ๊ณ ์๋ฃ
๋์: ์ฝ๋ฉ ์ธํฐ๋ทฐ ์์ ๋ถ์
https://takeuforward.org/data-structure/reverse-a-linked-list/
https://arminnorouzi.github.io/posts/2023/06/blog-post-3/
https://www.youtube.com/watch?v=2T-A_GFuoTo&t=650s
https://github.com/jwasham/coding-interview-university?tab=readme-ov-file#linked-lists
'์ฝ๋ฉํ ์คํธ > ์๊ณ ๋ฆฌ์ฆ&์๋ฃ๊ตฌ์กฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
2. Arrays (0) | 2024.03.02 |
---|
๋๊ธ