๊ณต๋ถํ๊ณ ์์์ผ ํ ๋งํ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ์ ๋ฆฌํฉ๋๋ค
python์ผ๋ก ์์ฑ๋ ์ฝ๋์ ์์๋ค์ด ์์ง๋ง, JS์๋ ํฐ ์ฐจ์ด๊ฐ ์๊ธฐ ๋๋ฌธ์ ์์ ์ฝ๋๋ก๋ ํ์ด์ฌ์ ๋ฃ์ด ๋์์ต๋๋ค
๋ํ ์ ๊ท ๊ต์ก ๊ณผ์ ์ผ๋ก ์ค๋ ๊ธฐ๊ฐ ๊ณต๋ถํด์ ๋ฐฐ์ด ๋ด์ฉ์ด ์๋๊ธฐ ๋๋ฌธ์ ๊น์ด ๋ฉด์์ ๋ถ์กฑํ ์ ์์ง๋ง,
์๋ฃ๊ตฌ์กฐ์ ๊ทธ์ ๋ฐ๋ฅธ ์์๋ฅผ ๊ฐ๋จํ ์์ฑํ์ฌ ์๋ฃ ๊ตฌ์กฐ๋ ์ด๋ค ๊ฒ๋ค์ด ์๋์ง ์๊ธฐ ์ํด ์ ๋ฆฌํ๊ณ ์์ต๋๋ค
-
์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ์
- ํจ์จ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํด์ผ ํ๋ ์ด์ (์)
-
๋ํ์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ ์ด๋ค ๊ฒ๋ค์ด ์๋์
- ์ ํ ๊ตฌ์กฐ
- ๋น ์ ํ ๊ตฌ์กฐ
์๋ฃ๊ตฌ์กฐ๋ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์๋ ๋ฐ์ดํฐ์ ๊ตฌ์กฐ๋ฅผ ์๋ฏธํฉ๋๋ค
์ฝ๋ ์์์ ํจ์จ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํด, ๋ฐ์ดํฐ ํน์ฑ์ ๋ฐ๋ผ, ์ฒด๊ณ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์กฐํํด์ผ ํฉ๋๋ค
์ด๋ค ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋๋์ ๋ฐ๋ผ, ์ฝ๋์ ํจ์จ์ด ๋ฌ๋ผ์ง ์ ์์ต๋๋ค
์ฐํธ๋ฒํธ: 5์๋ฆฌ ์ฐํธ๋ฒํธ๋ก ๊ตญ๊ฐ์ ๊ธฐ์ด๊ตฌ์ญ์ ์ ๊ณต
5์๋ฆฌ ์ฐํธ๋ฒํธ์์ ์ 3์๋ฆฌ๋ ์, ๊ตฐ, ์์น๊ตฌ๋ฅผ ํ๊ธฐ, ๋ค 2์๋ฆฌ๋ ์ผ๋ จ๋ฒํธ๋ก ๊ตฌ์ฑ
ํ์ ๊ด๋ฆฌ: ํ๋ , ๋ฐ, ๋ฒํธ๋ฅผ ํ์์๊ฒ ๋ถ์ฌํด์, ํ์๋ถ๋ฅผ ๊ด๋ฆฌ
XXํ๋ , X๋ฐ, X๋ฒ ํ์
๋ง์ฝ ์ ๊ด๋ฆฌ ๊ธฐ๋ฒ์ด ์๋ค๋ฉด, 3000๋ช ํ์ ์ค ํน์ ํ์์ ์ฐพ๊ธฐ ์ํด, ์ ์ฒด ํ์๋ถ๋ฅผ ๋ชจ๋ ํ์ด์ผ ํจ
์๋ฃ๊ตฌ์กฐ | ์๋ฃ๊ตฌ์กฐ |
---|---|
์ ํ ๊ตฌ์กฐ | ๋น์ ํ ๊ตฌ์กฐ |
๋ฆฌ์คํธ ์คํ ํ ๋ฑ |
ํธ๋ฆฌ ๊ทธ๋ํ |
์ถ์ฒ: https://boycoding.tistory.com/32
์ ํ ๊ตฌ์กฐ (Linear Structure)
๋ฐ์ดํฐ๋ค์ด ์ผ๋ ฌ๋ก ์ญ ์ ์ฅ๋์ด ์๋ ํํ
๋น ์ ํ ๊ตฌ์กฐ (Non-Linear Structure)
๋ฐ์ดํฐ๊ฐ ํธ๋ฆฌ ํํ๋ก ์ ์ฅ๋์ด ์๋ค๊ณ ์๊ฐํ๊ณ ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ
- ๋ฐ์ดํฐ๋ฅผ ๋์ดํ๊ณ , ๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ธ๋ฑ์ค์ ๋์ํ๋๋ก ๊ตฌ์ฑํ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- ํ์ด์ฌ์์๋ ๋ฆฌ์คํธ ํ์ ์ด ๋ฐฐ์ด ๊ธฐ๋ฅ์ ์ ๊ณตํจ
๋ฆฌ์คํธ๋ ์ ํ์ํ๊ฐ์?
- ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ํด
- ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ์ฅํ๊ธฐ ์ํด
์ฅ์
- ๋น ๋ฅธ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค
- ์ฒซ ๋ฐ์ดํฐ์ ์์น
[0]
์์ ์๋์ ์ธ ์์น๋ก ๋ฐ์ดํฐ์ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค (์ธ๋ฑ์ค ๋ฒํธ๋ก ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค)
๋จ์
- ๋ฐ์ดํฐ ์ถ๊ฐ/ ์ญ์ ๊ฐ ์ด๋ ต๋ค
- ๋ฏธ๋ฆฌ ์ต๋ ๊ธธ์ด๋ฅผ ์ง์ ํด์ผ ํจ
make a list using C
- C ์ธ์ด์์ ๋ฐฐ์ด์ ์ฌ์ฉํ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ต๋ ๊ธธ์ด๋ฅผ ์ฌ์ ์ ์ ์ํด์ค์ผ ํ๋ค
#include <stdio.h>
int main(int argc, char * argv[])
{
char country[3] = "US";
printf ("%c%c\n", country[0], country[1]);
printf ("%s\n", country);
return 0;
}
make a list using python
- Python์ ๊ฒฝ์ฐ ๋ฐฐ์ด(๋ฌธ์์ด)์ ๊ธธ์ด๋ฅผ ์ฌ์ ์ ์ ํด์ฃผ์ง ์์๋ ๋์ํ๋ค
- JS๋ํ ๊ธธ์ด๋ฅผ ์ฌ์ ์ ์ ํด์ฃผ์ง ์์๋ ๋์ํ๋ค
- ์ด๋ฌํ ํน์ง ๋๋ฌธ์ ํ์ด์ฌ๊ณผ JS์ ๋ฐฐ์ด์ด ์๋ฃ๊ตฌ์กฐ์ ๋ฐฐ์ด๊ณผ ๊ฐ๋ค๊ณ ๋ณผ ์๋ ์๋ค
country = 'US'
print (country)
>>> US
country = country + 'A'
print(country)
>>> USA
1 ์ฐจ์ ๋ฐฐ์ด
# 1์ฐจ์ ๋ฐฐ์ด: ๋ฆฌ์คํธ๋ก ๊ตฌํ์
data_list = [1, 2, 3, 4, 5]
print(data_list)
>>>
[1,2,3,4,5]
2 ์ฐจ์ ๋ฐฐ์ด
# 2์ฐจ์ ๋ฐฐ์ด: ๋ฆฌ์คํธ๋ก ๊ตฌํ์
data_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(data_list)
[
[1,2,3],
[4,5,6],
[7,8,9]
]
Queue ๊ตฌ์กฐ
- ์ค์ ์๋ ํ์์ ์ ์ฌ
- ๊ฐ์ฅ ๋จผ์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๊บผ๋ผ ์ ์๋ ๊ตฌ์กฐ
- ์์์ ์์ ๊ฐ์ฅ ๋จผ์ ์ค์ ์ ์ฌ๋์ด ์ ์ผ ๋จผ์ ์์์ ์ ์ ์ฅํ๋ ๊ฒ๊ณผ ๋์ผ
- FIFO(First-In, First-Out) ๋๋ LILO(Last-In, Last-Out) ๋ฐฉ์์ผ๋ก ์คํ๊ณผ ๊บผ๋ด๋ ์์๊ฐ ๋ฐ๋
- Enqueue: ํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๋ ๊ธฐ๋ฅ (JS์์ push)
- Dequeue: ํ์์ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๋ ๊ธฐ๋ฅ (JS์์ shift)
queue ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ ๋ค์ํ ํ ๊ตฌ์กฐ๋ก โ Queue(), โก LifoQueue(), โข PriorityQueue() ์ ๊ณต
ํ๋ก๊ทธ๋จ์ ์์ฑํ ๋ ํ๋ก๊ทธ๋จ์ ๋ฐ๋ผ ์ ํฉํ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉ
Queue(): ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ํ ์๋ฃ ๊ตฌ์กฐ
# ํ (Queue)
import queue
# FIFO QUEUE (์ผ๋ฐ์ ์ธ ๊ตฌ์กฐ์ ํ) ์ฌ์ฉํ๊ธฐ
data_queue = queue.Queue()
print('data_queue:', data_queue)
print('type:', type(data_queue))
print()
# ๋ฐ์ดํฐ ์ฝ์
(put)
data_queue.put(1)
data_queue.put(2)
data_queue.put(3)
print('data_queue.qsize():', data_queue.qsize()) >>> 3
print()
# ๋ฐ์ดํฐ ์ถ์ถ (get)
print('data_queue.get():', data_queue.get()) >>> 1
print('data_queue.get():', data_queue.get()) >>> 2
print('data_queue.get():', data_queue.get()) >>> 3
LifoQueue(): ๋์ค์ ์ ๋ ฅ๋ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ถ๋ ฅ๋๋ ๊ตฌ์กฐ (์คํ ๊ตฌ์กฐ๋ผ๊ณ ๋ณด๋ฉด ๋จ)
import queue
# LIFO QUEUE (์คํ๊ณผ ๊ฐ์ ๊ตฌ์กฐ์ ํ) ์ฌ์ฉํ๊ธฐ
data_queue = queue.LifoQueue()
print('data_queue:', data_queue)
print('type:', type(data_queue))
print()
# ๋ฐ์ดํฐ ์ฝ์
(put)
data_queue.put(1)
data_queue.put(2)
data_queue.put(3)
print('data_queue.qsize():', data_queue.qsize()) >>> 3
print()
# ๋ฐ์ดํฐ ์ถ์ถ (get)
print('data_queue.get():', data_queue.get()) >>> 3
print('data_queue.get():', data_queue.get()) >>> 2
print('data_queue.get():', data_queue.get()) >>> 1
PriorityQueue(): ๋ฐ์ดํฐ๋ง๋ค ์ฐ์ ์์๋ฅผ ๋ฃ์ด์, ์ฐ์ ์์๊ฐ ๋์ ์์ผ๋ก ๋ฐ์ดํฐ ์ถ๋ ฅ
# PriorityQueue() ์ฐ์ ์์๊ฐ ์๋ ํ ๋ง๋ค๊ธฐ
import queue
data_queue = queue.PriorityQueue()
# - ํํ ํ์ ( , )์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฝ์ธํ๋ค
# - ์ซ์๊ฐ ๋ฎ์์๋ก ์ฐ์ ์์๊ฐ ๋๋ค (1 <<<<< ์ฐ์ ์์๊ฐ ๋์ , .... , 15 <<<< ์ฐ์ ์์๊ฐ ๋ฎ์)
# - ์ฐ์ ์์๊ฐ ๋์ ํํ์ด ๋จผ์ Dequeue ๋๋ค
data_queue.put((10, "korea"))
data_queue.put((5, 1))
data_queue.put((15, "china"))
print()
print(data_queue.qsize()) # >>> 3
print()
print(data_queue.get()) # >>> (5,1)
print(data_queue.get()) # >>> (10, 'korea')
print(data_queue.get()) # >>> (15, 'china')
๋ฉํฐ ํ์คํน์ ์ํ ํ๋ก์ธ์ค ์ค์ผ์ฅด๋ง ๋ฐฉ์์ ๊ตฌํํ๊ธฐ ์ํด ๋ง์ด ์ฌ์ฉ๋๋ค
queue_list = list()
def enqueue(data):
queue_list.append(data)
def dequeue():
data = queue_list[0]
del queue_list[0]
return data
for index in range(10):
enqueue(index)
print('queue_list:', queue_list)
# >>> queue_list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
dequeue()
print('queue_list:', queue_list)
# >>> queue_list: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Stack ๊ตฌ์กฐ
- ๋ฐ์ดํฐ๋ฅผ ์ ํ์ ์ผ๋ก ์ ๊ทผํ ์ ์๋ ๊ตฌ์กฐ
- ํ์ชฝ ๋์์๋ง ์๋ฃ๋ฅผ ๋ฃ๊ฑฐ๋ ๋บ ์ ์๋ ๊ตฌ์กฐ
- ๊ฐ์ฅ ๋์ค์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๋นผ๋ผ ์ ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ
ํ(Queue) | ์คํ(Stack) |
---|---|
F.I.F.O First In First Out |
L.I.F.O Last In First Out |
์คํ ๊ตฌ์กฐ
์คํ์ LIFO(Last In, Fisrt Out) ๋๋ FILO(First In, Last Out) ๋ฐ์ดํฐ ๊ด๋ฆฌ ๋ฐฉ์์ ๋ฐ๋ฆ
LIFO: ๋ง์ง๋ง์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ์ถ์ถํ๋ ๋ฐ์ดํฐ ๊ด๋ฆฌ ์ ์ฑ FILO: ์ฒ์์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋ง์ง๋ง์ ์ถ์ถํ๋ ๋ฐ์ดํฐ ๊ด๋ฆฌ ์ ์ฑ
๋ํ์ ์ธ ์คํ์ ํ์ฉ
์ปดํจํฐ ๋ด๋ถ์ ํ๋ก์ธ์ค ๊ตฌ์กฐ์ ํจ์ ๋์ ๋ฐฉ์
์ฃผ์ ๊ธฐ๋ฅ
push(): ๋ฐ์ดํฐ๋ฅผ ์คํ์ ๋ฃ๊ธฐ pop(): ๋ฐ์ดํฐ๋ฅผ ์คํ์์ ๊บผ๋ด๊ธฐ
์คํ์ ์ฅ๋จ์
-
์ฅ์ ๐ฅ
- ๊ตฌ์กฐ๊ฐ ๋จ์ํด์, ๊ตฌํ์ด ์ฝ๋ค
- ๋ฐ์ดํฐ ์ ์ฅ/์ฝ๊ธฐ ์๋๊ฐ ๋น ๋ฅด๋ค
-
๋จ์ ๐ฅ
-
๋ฐ์ดํฐ ์ต๋ ๊ฐ์๋ฅผ ๋ฏธ๋ฆฌ ์ ํด์ผ ํ๋ค
-
ํ์ด์ฌ์ ๊ฒฝ์ฐ ์ฌ๊ท ํจ์ ํธ์ถ์ 1000๋ฒ๊น์ง ๊ฐ๋ฅํ๋ค
-
์ ์ฅ ๊ณต๊ฐ์ ๋ญ๋น๊ฐ ๋ฐ์ํ ์ ์๋ค
-
๋ฏธ๋ฆฌ ์ต๋ ๊ฐ์๋งํผ ์ ์ฅ ๊ณต๊ฐ์ ํ๋ณดํด์ผ ํ๋ค
-
-
์คํ์ ๋จ์ํ๊ณ ๋น ๋ฅธ ์ฑ๋ฅ์ ์ํด ์ฌ์ฉ๋๋ฏ๋ก, ๋ณดํต ๋ฐฐ์ด ๊ตฌ์กฐ๋ฅผ ํ์ฉํด์ ๊ตฌํํ๋ ๊ฒ์ด ์ผ๋ฐ์ ์
list ์๋ฃํ์ ๋ด์ฅ ๋ฉ์๋๋ก append(push), pop() ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค
# ์คํ (Stack)
# ํ์ ๋ฌ๋ฆฌ ํ์ด์ฌ, JS ์์ ๊ธฐ๋ณธ ์ ๊ณตํ๋ ๋ฆฌ์คํธ๋ฅผ ํตํด์ ๊ตฌํ์ด ๊ฐ๋ฅํ๋ค
# ํ์ ๊ฒฝ์ฐ data = queue.Queue() ์ ๊ฐ์ด ์ธ์คํด์ค๋ก ๋ง๋ค์ด์ ์ฌ์ฉํ์์
# append: ์ฝ์
ํ๊ธฐ (push)
# pop: ๊บผ๋ด๊ธฐ (pop)
data_stack = list()
data_stack.append(1)
data_stack.append(2)
print('data_stack:', data_stack) >>> [1,2]
print()
data_stack.pop()
print('โ data_stack.pop():', data_stack) >>> [1]
print()
data_stack.pop()
print('โก data_stack.pop():', data_stack) >>> [0]
๋ฆฌ์คํธ ๋ณ์๋ก ์คํ์ ๋ค๋ฃจ๋ pop, push ๊ธฐ๋ฅ ๊ตฌํํด๋ณด๊ธฐ
stack_list = list()
def push(data):
stack_list.append(data)
def pop():
data = stack_list[-1]
del stack_list[-1]
return data
for elem in range(10):
push(elem)
print('stack_list', stack_list)
# >>> stack_list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print()
pop()
print('stack_list', stack_list)
# >>> stack_list [0, 1, 2, 3, 4, 5, 6, 7, 8]
Linked List ๊ตฌ์กฐ
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ผ๊ณ ๋ ํ๋ค
- ๋ฐฐ์ด์ ์์ฐจ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๊ณต๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋์ดํ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- ๋งํฌ๋ ๋ฆฌ์คํธ๋ ๋จ์ด์ง ๊ณณ์ ์กด์ฌํ๋ ๋ฐ์ดํฐ๋ฅผ ํ์ดํ๋ก ์ฐ๊ฒฐํด์ ๊ด๋ฆฌํ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- ๋ณธ๋ C์ธ์ด์์๋ ์ฃผ์ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ด์ง๋ง, ํ์ด์ฌ์ ๋ฆฌ์คํธ ํ์ ์ด ๋งํฌ๋ ๋ฆฌ์คํธ์ ๊ธฐ๋ฅ์ ๋ชจ๋ ์ง์
๋งํฌ๋ ๋ฆฌ์คํธ ๊ธฐ๋ณธ ๊ตฌ์กฐ์ ์ฉ์ด
๋ ธ๋(Node): ๋ฐ์ดํฐ ์ ์ฅ ๋จ์ (๋ฐ์ดํฐ๊ฐ, ํฌ์ธํฐ) ๋ก ๊ตฌ์ฑ
ํฌ์ธํฐ(pointer): ๊ฐ ๋ ธ๋ ์์์, ๋ค์์ด๋ ์ด์ ์ ๋ ธ๋์์ ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ณต๊ฐ
์ผ๋ฐ์ ์ธ ๋งํฌ๋ ๋ฆฌ์คํธ ํํ
(์ถ์ฒ: wikipedia, https://en.wikipedia.org/wiki/Linked_list)
๋งํฌ๋ ๋ฆฌ์คํธ์ ์ฅ๋จ์ (์ ํต์ ์ธ C ์ธ์ด์์์ ๋ฐฐ์ด๊ณผ ๋งํฌ๋ ๋ฆฌ์คํธ)
-
์ฅ์
- ๋ฏธ๋ฆฌ ๋ฐ์ดํฐ ๊ณต๊ฐ์ ํ ๋นํ์ง ์์๋ ๋๋ค
- <-> ๋ฐฐ์ด์ ๋ฏธ๋ฆฌ ๋ฐ์ดํฐ ๊ณต๊ฐ์ ํ ๋นํด์ผ ํจ
- ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐ ํ ๋๋ง๋ค ๋์ ์ผ๋ก ํฌ๊ธฐ๊ฐ ๋์ด๋๋ค
- ์์ ๊ฒ์ ์ ์ฒซ ๋ฒ์งธ ๋ ธ๋๋ถํฐ ๋ง์ง๋ง ๋ ธ๋๊น์ง ์ผ์ผ์ด ํ์ธํ๊ธฐ ๋๋ฌธ์ O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค
- ์ฝ์ ๋๋ ์ญ์ ์ฐ์ฐ ์์ ํด๋น ์์๋ฅผ ๊ฒ์ํ ํ ์ญ์ , ์ฝ์ ์ฐ์ฐ์ด ์ด๋ฃจ์ด์ง๋ฏ๋ก O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค
- ์ฆ, ์ฝ์ , ์ญ์ ๊ฐ ์ฆ์ ๊ฒฝ์ฐ Linked List๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค
- why? ๋ฐฐ์ด ๊ฒฝ์ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ฌ์ ์ ์ ํด์ค์ผ ํ๊ธฐ ๋๋ฌธ
-
๋จ์
- ์ฐ๊ฒฐ์ ์ํ ๋ณ๋ ๋ฐ์ดํฐ ๊ณต๊ฐ์ด ํ์ํ๋ฏ๋ก, ์ ์ฅ ๊ณต๊ฐ ํจ์จ์ด ๋์ง ์์
- ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ์ฐพ๋ ์๊ฐ์ด ํ์ํ๋ฏ๋ก ์ ๊ทผ ์๋๊ฐ ๋๋ฆผ
- ์ค๊ฐ ๋ฐ์ดํฐ ์ญ์ ์, ์๋ค ๋ฐ์ดํฐ์ ์ฐ๊ฒฐ์ ์ฌ๊ตฌ์ฑํด์ผ ํ๋ ๋ถ๊ฐ์ ์ธ ์์ ํ์
- ๊ฒ์์ด ์ฆ์ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค
๋๋ธ ๋งํฌ๋ ๋ฆฌ์คํธ(Doubly linked list) ๊ธฐ๋ณธ ๊ตฌ์กฐ
- ๋จ๋ฐฉํฅ ๋งํฌ๋ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ ๋ฐ๋์ ์ฐ๋ฆฌ๊ฐ ์ค์ ํ head ์ฐจ๋ก๋ก ๋ฐ์ดํฐ๋ฅผ ์ฐพ์๊ฐ์
- ๋๋ธ ๋งํฌ๋ ๋ฆฌ์คํธ๋ ์ ๋ค ๋ฐฉํฅ ๋ชจ๋ ๋ ธ๋ ํ์์ด ๊ฐ๋ฅํจ
- ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ผ๊ณ ๋ ํจ
- ์ฅ์ : ์๋ฐฉํฅ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์์ด์ ๋ ธ๋ ํ์์ด ์์ชฝ์ผ๋ก ๋ชจ๋ ๊ฐ๋ฅ
(์ถ์ฒ: wikipedia, https://en.wikipedia.org/wiki/Linked_list)
ํด์ฌ ํ
์ด๋ธ(Hash Table) ๊ตฌ์กฐ
ํด์ฌ ํ ์ด๋ธ(Hash Table): ํค(Key)์ ๋ฐ์ดํฐ(Value)๋ฅผ ์ ์ฅํ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- Key๋ฅผ ํตํด ๋ฐ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์ฌ ์ ์์ผ๋ฏ๋ก, ์๋๊ฐ ํ๊ธฐ์ ์ผ๋ก ๋นจ๋ผ์ง
- (ํน์ ์กฐ๊ฑด์ ๋ง์ถฐ ๋ฐฐ์ด์ ๋ชจ๋ ์ํํ ํ์๊ฐ ์๋ค๋ ์๋ฆฌ)
- ํ์ด์ฌ ๋์ ๋๋ฆฌ(Dictionary) ํ์ ์ด ํด์ฌ ํ ์ด๋ธ์ ์: Key๋ฅผ ๊ฐ์ง๊ณ ๋ฐ๋ก ๋ฐ์ดํฐ(Value)๋ฅผ ๊บผ๋ผ ์ ์์
- ๋ณดํต ๋ฐฐ์ด๋ก ๋ฏธ๋ฆฌ Hash Table ์ฌ์ด์ฆ๋งํผ ์์ฑ ํ์ ์ฌ์ฉ (๊ณต๊ฐ๊ณผ ํ์ ์๊ฐ์ ๋ง๋ฐ๊พธ๋ ๊ธฐ๋ฒ)
- ํด์ฌ ํ ์ด๋ธ์ ๊ธธ์ด(์ฌ๋กฏ์ ๊ฐ์)๋ฅผ ๋๋ฆฌ๋ ๋ฐฉ๋ฒ
- ๋จ, ํ์ด์ฌ์์๋ ํด์ฌ๋ฅผ ๋ณ๋๋ก ๊ตฌํํ ์ด์ ๊ฐ ์์ (๋์ ๋๋ฆฌ ํ์ { 'key': 'value' } ์ ์ ๊ณตํ๊ธฐ ๋๋ฌธ)
- JS ๋ํ ๋ณ๋๋ก ๊ตฌํํ ํ์๊ฐ ์๋ค (๊ฐ์ฒด ํ์ { key: 'value' } ์ ์ ๊ณตํ๊ธฐ ๋๋ฌธ)
์์๋ ์ฉ์ด
- ํด์ฌ(Hash): ์์ ๊ฐ์ ๊ณ ์ ๊ธธ์ด๋ก ๋ณํํ๋ ๊ฒ
- ํด์ฌ ํ ์ด๋ธ(Hash Table): ํค ๊ฐ์ ์ฐ์ฐ์ ์ํด ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- ํด์ฑ ํจ์(Hashing Function): Key๋ฅผ ํด์ฑ ํจ์๋ก ์ฐ์ฐํด์, ํด์ฌ ๊ฐ์ ์์๋ด๊ณ , ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํด์ฌ ํ ์ด๋ธ์์ ํด๋น Key์ ๋ํ ๋ฐ์ดํฐ ์์น๋ฅผ ์ผ๊ด์ฑ์๊ฒ ์ฐพ์ ์ ์์
- ์ฌ๋กฏ(Slot): ํ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๊ณต๊ฐ
- ์ ์ฅํ ๋ฐ์ดํฐ์ ๋ํด Key๋ฅผ ์ถ์ถํ ์ ์๋ ๋ณ๋ ํจ์๋ ์กด์ฌํ ์ ์์
ํด์ฌ ํ
์ด๋ธ์ ์ฅ๋จ์ ๊ณผ ์ฃผ์ ์ฉ๋
-
์ฅ์
- ๋ฐ์ดํฐ ์ ์ฅ/์ฝ๊ธฐ ์๋๊ฐ ๋น ๋ฅด๋ค. (๊ฒ์ ์๋๊ฐ ๋น ๋ฅด๋ค.)
- ํด์ฌ๋ ํค์ ๋ํ ๋ฐ์ดํฐ๊ฐ ์๋์ง(์ค๋ณต) ํ์ธ์ด ์ฝ๋ค
- ํด์ฌ๋ ํค๋ฅผ ๋ฐํ์ผ๋ก ํ ๋ฐ์ดํฐ์ ์ฌ๋ถ(์ ๋ฌด)๋ฅผ ํ์ ํ๊ธฐ ์ฝ๋ค
-
๋จ์
- ์ผ๋ฐ์ ์ผ๋ก ์ ์ฅ๊ณต๊ฐ์ด ์ข ๋ ๋ง์ด ํ์ํ๋ค
- ์ฌ๋ฌ ํค์ ํด๋นํ๋ ์ฃผ์๊ฐ ๋์ผํ ๊ฒฝ์ฐ ์ถฉ๋์ ํด๊ฒฐํ๊ธฐ ์ํ ๋ณ๋ ์๋ฃ๊ตฌ์กฐ๊ฐ ํ์ํ๋ค
- ํด์ ํจ์๋ฅผ ํตํด ๋๋ ์ ธ ์ ์ฅ๋๋ ํด์ฌ ํ ์ด๋ธ์ ์ฃผ์๊ฐ ๊ฐ์๋ฐ, ๋ณ๋์ ์ฒ๋ฆฌ๋ฅผ ํ์ง ์์ ๊ฒฝ์ฐ
- ํค๋ฅผ ๋ฐํ์ผ๋ก ํ ๋ฐ์ดํฐ๊ฐ ๋ฎ์ด์์์ง ๊ฐ๋ฅ์ฑ์ด ์๋ค.
- ์ค๋ณต์ด ์ผ์ด๋์ง ์๋๋ก ํด์ฌ ํ ์ด๋ธ์ ๊ณต๊ฐ์ ๋๊ฒ ์ค๊ณํด์ผ ํ๋ค
-
์ฃผ์ ์ฉ๋
- ๊ฒ์์ด ๋ง์ด ํ์ํ ๊ฒฝ์ฐ
- ์ ์ฅ, ์ญ์ , ์ฝ๊ธฐ๊ฐ ๋น๋ฒํ ๊ฒฝ์ฐ
- ์บ์ฌ ๊ตฌํ์ (์ค๋ณต ํ์ธ์ด ์ฝ๊ธฐ ๋๋ฌธ)
- ์บ์ฌ๋ ๋์ผํ ํ์ด์ง๋ฅผ ๋ถ๋ฌ์ค๋ ๊ฒฝ์ฐ https://naver.com, ๋ณ๊ฒฝ๋๋ ๋ฐ์ดํฐ ์ด์ธ์๋
- ์ฌ์ฉ์์ ์บ์ฌ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ์ฌ ์๋ฒ๋ก๋ถํฐ ๋ถ๋ฌ์ค๋ ๋ฐ์ดํฐ์ ์์ ๊ด๋ฆฌํ๊ธฐ ์ํ ๋ฉ๋ชจ๋ฆฌ์ด๋ค
ํธ๋ฆฌ(Tree) ๊ตฌ์กฐ
ํธ๋ฆฌ: ๋
ธ๋(node)์ ๋ธ๋์น(branch)๋ฅผ ์ด์ฉํด์, ์ฌ์ดํด์ ์ด๋ฃจ์ง ์๋๋ก ๊ตฌ์ฑํ ๋ฐ์ดํฐ ๊ตฌ์กฐ
- ์ฌ์ดํด์ ์๋ ์ด๋ฏธ์ง๋ฅผ ๊ธฐ์ค์ผ๋ก 5 - 3 - 6 ์์ผ๋ก ์์ ๊ทธ๋ฆฌ๋ฉฐ ํ์ํ๋ ๊ฒ์ ์๋ฏธ
- ํธ๋ฆฌ ๊ตฌ์กฐ์์ Siblings ๋ผ๋ฆฌ๋ ๋ธ๋์น๋ก ์ด์ด์ง์ง ์๋๋ค ๐ฅ
์ค์ ๋ก ์ด๋์ ๋ง์ด ์ฌ์ฉ๋๋?
- ํธ๋ฆฌ ์ค ์ด์ง ํธ๋ฆฌ (Binary Tree)ํํ์ ๊ตฌ์กฐ๋ก, ํ์(๊ฒ์) ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ์ ์ํด ๋ง์ด ์ฌ์ฉ๋จ
- ํธ๋ฆฌ ๋ด๋ถ์ ์ด๋ค ๊ฐ์ ๊ฐ์ง ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋์ง์ ์ ๋ฌด๋ฅผ ํ์ ํ๊ธฐ ์ฝ๋ค
- ๋ฐฐ์ด์ ํตํด ๋ฐฐ์ด์ ๊ธธ์ด๋งํผ ์ ๋ถ ์ํํ๋ ๊ฒ ๋ณด๋ค ๊ธฐ์ค(left right)์ ๊ฐ์ง๊ณ ํ์ํ๋ฏ๋ก ๋์ฑ ๋น ๋ฅด๋ค
- Node: ํธ๋ฆฌ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ธฐ๋ณธ ์์ (๋ฐ์ดํฐ์ ๋ค๋ฅธ ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๋ํ Branch ์ ๋ณด ํฌํจ)
- Root Node: ํธ๋ฆฌ ๋งจ ์(์ต ์๋จ)์ ์๋ ๋ ธ๋
- Level: ์ต์์ ๋ ธ๋๋ฅผ Level 0์ผ๋ก ํ์์ ๋, ํ์ Branch๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๊น์ด๋ฅผ ๋ํ๋
- Parent Node: ์ด๋ค ๋ ธ๋์ ๋ค์ ๋ ๋ฒจ์ ์ฐ๊ฒฐ๋ ๋ ธ๋
- Child Node: ์ด๋ค ๋ ธ๋์ ์์ ๋ ๋ฒจ์ ์ฐ๊ฒฐ๋ ๋ ธ๋
- Leaf Node (Terminal Node): Child Node๊ฐ ํ๋๋ ์๋ ๋ ธ๋
- Sibling (Brother Node): ๋์ผํ Parent Node๋ฅผ ๊ฐ์ง ๋ ธ๋
- Depth: ํธ๋ฆฌ์์ Node๊ฐ ๊ฐ์ง ์ ์๋ ์ต๋ Level (๊น์ด๋ฅผ ๋ํ๋)
-
์ด์ง ํธ๋ฆฌ: ๋ ธ๋์ ์ต๋ ๋ธ๋์น๊ฐ 2๊ฐ์ธ ํธ๋ฆฌ
- ์ด์ง ํธ๋ฆฌ๊ตฌ์กฐ์์ ์๋ ์ด์ง ํ์ ํธ๋ฆฌ ํ์์ผ๋ก ๋ง์ด ์ฐ๊ธฐ ๋๋ฌธ์ ์ด์ง ํธ๋ฆฌ = ์ด์ง ํ์ ํธ๋ฆฌ๋ผ๊ณ ์๊ฐํ๋ ๊ฒฝ์ฐ๋ ์๋ค
- ํ์ง๋ง ๋์ ๊ฐ์ง ์์
- ์ด์ง ํธ๋ฆฌ๋ ๋ฃจํธ ๋ ธ๋์ ์ต๋ ๋ธ๋์น๊ฐ 2๊ฐ์ธ ํธ๋ฆฌ์ด๋ฉฐ, ์ฌ์ดํด์ ์ด๋ฃจ์ง ์๋๋ก ๊ตฌ์ฑํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ด์ง๋ง,
- ์ด์ง ํ์ ํธ๋ฆฌ๋ ํด๋น ์ด์ง ํธ๋ฆฌ์ ํน์ง์ ๋ฐํ์ผ๋ก ํน์ ์กฐ๊ฑด์ ๋ถ์ธ ํธ๋ฆฌ์ด๋ค
-
์ด์ง ํ์ ํธ๋ฆฌ: ์ด์ง ํธ๋ฆฌ์ ๋ค์๊ณผ ๊ฐ์ ์ถ๊ฐ์ ์ธ ์กฐ๊ฑด์ด ์๋ ํธ๋ฆฌ
- ์ผ์ชฝ ๋ ธ๋๋ ํด๋น ๋ ธ๋๋ณด๋ค ์์ ๊ฐ, ์ค๋ฅธ์ชฝ ๋ ธ๋๋ ํด๋น ๋ ธ๋๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ์ง๊ณ ์์
- ์ฃผ์ ์ฉ๋: ๋ฐ์ดํฐ ๊ฒ์(ํ์)
- ์ฅ์ : ํ์ ์๋๋ฅผ ๊ฐ์ ํ ์ ์์
- steps: ๋จ๊ณ์ ๊ฐ์ง์๋ฅผ ๋ณด๋ฉด ์ด์ง ํธ๋ฆฌ๊ฐ ํจ์ฌ ๋น ๋ฅด๊ฒ ๊ฒ์์ ํ ์ ์๋ค
- ์๋ฃ๊ตฌ์กฐ์ ํ: ๋ฐ์ดํฐ์์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์ง ํธ๋ฆฌ(Complete Binary Tree)
์์ ์ด์ง ํธ๋ฆฌ
: ๋ ธ๋๋ฅผ ์ฝ์ ํ ๋ ์ตํ๋จ์ ์ผ์ชฝ ๋ ธ๋๋ถํฐ ์ฐจ๋ก๋๋ก ์ฝ์ ํ๋ ํธ๋ฆฌ- ํธ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ๋ณํ๋ ์ ์ฑ ์ ์ฐ๊ณ ์๋ค๊ณ ์๊ฐํ๋ฉด ๋จ
- js์ ์คํ ์ปจํ ์คํธ์์ ๊ฐ์ฒด๋ฅผ ๋ด์๋๋ ๊ณต๊ฐ์ธ Heap ๋ฉ๋ชจ๋ฆฌ์ ์๋ฃ๊ตฌ์กฐ์์์ Heap์ ๋ค๋ฆ ๐ฅ
์ถ์ฒ: http://sjkitpro.blogspot.com/2018/07/heap.html
ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด 4๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๊ฐ์ง๊ฒ ๋๋ค.
์ด์ค Heap ์์ญ์ ์ฌ์ฉ์๊ฐ ๋์ ํ ๋น์ ํ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ค.
C์ธ์ด์์๋ malloc, java์์๋ new ํค์๋๋ก Heap ์์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ์ ์๋ค.
Heap ๋ฉ๋ชจ๋ฆฌ์ ํด์ ๋ C์์๋ free ํจ์๋ก ํด์ ํ๋ฉฐ, java์์๋ JVM์์ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ์ง์ฐ๋ ์์ ์ ํด์ ๋๋ค.
ํ์ ์์ ์ด์ง ํธ๋ฆฌ์ด๋ค. ์ต์ ๊ฐ ํน์ ์ต๋ ๊ฐ์ ์ฐพ์๋ด๋ ์ฐ์ฐ์ ์ ํฉํ๋ค.
ํ์๋ ์ต์ ํ๊ณผ ์ต๋ ํ์ด ์๋ค. ์ต๋ ํ์ ๋ฃจํธ๋ ธ๋๋ก ๊ฐ์๋ก ๊ฐ์ด ์ปค์ง๋ฉฐ, ์ต์ ํ์ ๋ฃจํธ๋ ธ๋๋ก ๊ฐ์๋ก ๊ฐ์ด ์์์ง๋ค.
-
ํ์ ์ฌ์ฉํ๋ ์ด์
- ๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ , ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ์ผ๋ ค๋ฉด O(n)์ด ๊ฑธ๋ฆฐ๋ค (์ ์ฒด๋ฅผ ์ํํด์ผ ํ๊ธฐ ๋๋ฌธ)
- ์ด์ ๋ฐํด, ํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ , ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ์ผ๋ฉด $ O(log n) $ ์ด ๊ฑธ๋ฆผ
- ์ฐ์ ์์ ํ์ ๊ฐ์ด ์ต๋๊ฐ ๋๋ ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์์ผ ํ๋ ์๋ฃ๊ตฌ์กฐ ๋ฐ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๋ฑ์ ํ์ฉ๋จ
์๊ฐ ๋ณต์ก๋ ์์
O(1) < O( ๐๐๐๐ ) < O(n) < O(n ๐๐๐๐ ) < O( ๐2 ) < O( 2๐ ) < O(n!)
- ํ์ ์ต๋๊ฐ์ ๊ตฌํ๊ธฐ ์ํ ๊ตฌ์กฐ (์ต๋ ํ, Max Heap)์, ์ต์๊ฐ์ ๊ตฌํ๊ธฐ ์ํ ๊ตฌ์กฐ (์ต์ ํ, Min Heap)๋ก ๋ถ๋ฅํ ์ ์์
- ํ์ ๋ค์๊ณผ ๊ฐ์ด ๋ ๊ฐ์ง ์กฐ๊ฑด๐ฅ ์ ๊ฐ์ง๊ณ ์๋ ์๋ฃ๊ตฌ์กฐ์
โ ๊ฐ ๋ ธ๋์ ๊ฐ์ ํด๋น ๋ ธ๋์ ์์ ๋ ธ๋๊ฐ ๊ฐ์ง ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค. (์ต๋ ํ์ ๊ฒฝ์ฐ) - ์ต์ ํ์ ๊ฒฝ์ฐ๋ ๊ฐ ๋ ธ๋์ ๊ฐ์ ํด๋น ๋ ธ๋์ ์์ ๋ ธ๋๊ฐ ๊ฐ์ง ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ์์
โก ์์ ์ด์ง ํธ๋ฆฌ ํํ๋ฅผ ๊ฐ์ง๋ค
-
๊ณตํต์ : ํ๊ณผ ์ด์ง ํ์ ํธ๋ฆฌ๋ ๋ชจ๋ ์ด์ง ํธ๋ฆฌ์ (์์ ๋ ธ๋๊ฐ ์ต๋ 2๊ฐ๊ฐ ์๋ ํธ๋ฆฌ ๊ตฌ์กฐ)
-
์ฐจ์ด์ :
- ํ์ ๊ฐ ๋ ธ๋์ ๊ฐ์ด ์์ ๋ ธ๋๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์(Max Heap์ ๊ฒฝ์ฐ)
- ์ด์ง ํ์ ํธ๋ฆฌ๋ ์ผ์ชฝ ์์ ๋ ธ๋์ ๊ฐ์ด ๊ฐ์ฅ ์๊ณ , ๊ทธ ๋ค์ ๋ถ๋ชจ ๋ ธ๋, ๊ทธ ๋ค์ ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋ ๊ฐ์ด ๊ฐ์ฅ ํผ
- ํ์ ์ด์ง ํ์ ํธ๋ฆฌ์ ์กฐ๊ฑด์ธ ์์ ๋ ธ๋์์ ์์ ๊ฐ์ ์ผ์ชฝ, ํฐ ๊ฐ์ ์ค๋ฅธ์ชฝ์ด๋ผ๋ ์กฐ๊ฑด์ ์์
- ํ์ ์ผ์ชฝ ๋ฐ ์ค๋ฅธ์กฑ ์์ ๋ ธ๋์ ๊ฐ์ ์ค๋ฅธ์ชฝ์ด ํด ์๋ ์๊ณ , ์ผ์ชฝ์ด ํด ์๋ ์์
- ์กฐ๊ฑด์ ์ ํด๋ ๊ฒ์ด ์๋ค๋ ๋ป(ํ ๊ตฌ์กฐ์ ๋ค์ด์ค๋ฉด์ ํ๋ณํ๋ค)
- ์ด์ง ํ์ ํธ๋ฆฌ์ ๋ชฉ์ ์ ํ์์ ์ํ ๊ตฌ์กฐ์ด๋ค (๊ฐ์ ์ ๋ฌด ํ๋ณ)
- ํ์ ์ต๋/์ต์๊ฐ ๊ฒ์์ ์ํ ๊ตฌ์กฐ ์ค ํ๋๋ก ์ดํดํ๋ฉด ๋จ (๋ฃจํธ ๋ ธ๋์๋ ํญ์ ์ต๋/์ต์ ๊ฐ์ด ์กด์ฌํ๋ฏ๋ก)
๊ทธ๋ํ (Graph) ๋?
- ๊ทธ๋ํ๋ ์ค์ ์ธ๊ณ์ ํ์์ด๋ ์ฌ๋ฌผ์ ์ ์ (Vertex) ๋๋ ๋ ธ๋(Node)์ ๊ฐ์ (Edge)๋ก ํํํ๊ธฐ ์ํด ์ฌ์ฉ
- ์์ ์ง์์ ํ์ฌ๋ก ๊ฐ๋ ๊ฒฝ๋ก๋ฅผ ๊ทธ๋ํ๋ก ํํํ ์
๋ ธ๋(Node) = ์ ์ (Vertex): ์์น๋ฅผ ๋งํจ
๊ฐ์ (Edge) = ๋งํฌ = ๋ธ๋์น: ์์น ๊ฐ์ ๊ด๊ณ๋ฅผ ํ์ํ ์ ์ผ๋ก ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํ ์ ์ด๋ผ๊ณ ๋ณด๋ฉด ๋จ (link ๋๋ branch๋ผ๊ณ ๋ ํจ)
์ธ์ ์ ์ (Adjacent Vertex): ๊ฐ์ ์ผ๋ก ์ง์ ์ฐ๊ฒฐ๋ ์ ์ (๋๋ ๋ ธ๋)
๋์ฌ๊ฒจ ๋ณผ ๊ทธ๋ํ ์ข ๋ฅ
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ
- ๋ฐฉํฅ ๊ทธ๋ํ
- ๊ฐ์ค์น ๊ทธ๋ํ
- ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ
- ๊ฐ์ ์ ํตํด, ๋ ธ๋๋ ์๋ฐฉํฅ์ผ๋ก ๊ฐ ์ ์์
- ๋ณดํต ๋ ธ๋ A,B๊ฐ ์ฐ๊ฒฐ๋์ด ์์ ๊ฒฝ์ฐ (A,B) ๋๋ (B,A)๋ก ํ๊ธฐ
- ๊ฐ์ ์ ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ
- ๋ณดํต ๋
ธ๋ A, B๊ฐ A -> B ๋ก ๊ฐ๋ ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ๋์ด ์์ ๊ฒฝ์ฐ,
<A, B>
๋ก ํ๊ธฐ (<B, A>
๋B -> A
๋ก ๊ฐ๋ ๊ฐ์ ์ด ์๋ ๊ฒฝ์ฐ์ด๋ฏ๋ก<A, B>
์ ๋ค๋ฆ)
- ๊ฐ์ ์ ๋น์ฉ ๋๋ ๊ฐ์ค์น๊ฐ ํ ๋น๋ ๊ทธ๋ํ
-
์ฐ๊ฒฐ ๊ทธ๋ํ (Connected Graph)
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ ์๋ ๋ชจ๋ ๋ ธ๋์ ๋ํด ํญ์ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ
-
๋น์ฐ๊ฒฐ ๊ทธ๋ํ (Disconnected Graph)
- ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ํน์ ๋ ธ๋์ ๋ํด ๊ฒฝ๋ก๊ฐ ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ
-
์ฌ์ดํด (Cycle)
- ๋จ์ ๊ฒฝ๋ก์ ์์ ๋ ธ๋์ ์ข ๋ฃ ๋ ธ๋๊ฐ ๋์ผํ ๊ฒฝ์ฐ
-
๋น์ํ ๊ทธ๋ํ (Acyclic Graph)
- ์ฌ์ดํด์ด ์๋ ๊ทธ๋ํ
- ๊ทธ๋ํ์ ๋ชจ๋ ๋ ธ๋๊ฐ ์๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ทธ๋ํ
ํธ๋ฆฌ๋ ๊ทธ๋ํ ์ค์ ์ํ ํน๋ณํ ์ข ๋ฅ๋ผ๊ณ ๋ณผ ์ ์์ (ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ํ ์ข ๋ฅ์ด๋ค)
๊ทธ๋ํ | ํธ๋ฆฌ | |
---|---|---|
์ ์ | ๋ ธ๋์ ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํ๋ ๊ฐ์ ์ผ๋ก ํํ๋๋ ์๋ฃ ๊ตฌ์กฐ | ๊ทธ๋ํ์ ํ ์ข ๋ฅ, ๋ฐฉํฅ์ฑ์ด ์๋ ๋น์ํ ๊ทธ๋ํ |
๋ฐฉํฅ์ฑ | ๋ฐฉํฅ ๊ทธ๋ํ, ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ๋ ๋ค ์กด์ฌํจ | ๋ฐฉํฅ ๊ทธ๋ํ๋ง ์กด์ฌํจ |
์ฌ์ดํด | ์ฌ์ดํด ๊ฐ๋ฅํจ, ์ํ ๋ฐ ๋น์ํ ๊ทธ๋ํ ๋ชจ๋ ์กด์ฌํจ | ๋น์ํ ๊ทธ๋ํ๋ก ์ฌ์ดํด์ด ์กด์ฌํ์ง ์์ |
๋ฃจํธ ๋ ธ๋ | ๋ฃจํธ ๋ ธ๋ ์กด์ฌํ์ง ์์ | ๋ฃจํธ ๋ ธ๋ ์กด์ฌํจ |
๋ถ๋ชจ/์์ ๊ด๊ณ | ๋ถ๋ชจ ์์ ๊ฐ๋ ์ด ์กด์ฌํ์ง ์์ | ๋ถ๋ชจ ์์ ๊ด๊ณ๊ฐ ์กด์ฌํจ |