[Data_Structer] Queue & Stack
Queue & Stack
Queue
queue๋ ์ ์ ์ ์ถ FIFO(First In First Out)์ ์๋ฃ๊ตฌ์กฐ ์๊ฐ๋ณต์ก๋๋ enqueue O(1) , dequeue O(1)
ํ์ฉ ์์๋ Cache๊ตฌํ
, ํ๋ก์ธ์ค ๊ด๋ฆฌ
, ๋๋น์ฐ์ ํ์(BFS)
๐ก ๊ธฐ์ด์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ก ๋ฉด์ ์์ ๊ฐ๋จํ ์ง๋ฌธ์ผ๋ก ์ข ์ข ๋์ค๋ ๋ฌธ์ . LIFO์ธ stack๊ณผ ๋ค๋ฅด๊ฒ FIFO์๋ฃ๊ตฌ์กฐ์์ ๊ธฐ์ต ๋ํ ํ์ฉ ์์๋ค๊ณผ Circular Queue ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ ์์์ผํ๋ค.
FIFO
queue๋ ์๊ฐ ์์์ ๋จผ์ ์ง์ด ๋ฃ์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋์ค๋ ์ ์ ์ ์ถ FIFO(First In First Out)ํ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ
enqueue & dequeue
queue์์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ enqueue
queue์์ ๋ฐ์ดํฐ๋ฅผ ์ถ์ถ ํ๋ ๊ฒ์ dequeue
enqueue์ ๊ฒฝ์ฐ queue์ ๋งจ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ฉด ์๋ฃ๋๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(1)
์ด์ ๋น์ทํ๊ฒ dequeue์ ๊ฒฝ์ฐ ๋งจ ์์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด ์๋ฃ ๋๊ธฐ ๋๋ฌธ์ ๋์ผํ๊ฒ O(1)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
๊ตฌํ ๋ฐฉ์
-
Array-Based queue: enqueue์ dequeue ๊ณผ์ ์์ ๋จ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๊น๋๋ค. ๋ฐ๋ผ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๋ฅผ ์ค์ด๊ธฐ ์ํด ์ฃผ๋ก Circular queueํ์์ผ๋ก ๊ตฌํ
-
List-Based: ์ฌํ ๋น์ด๋ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น์ ๊ฑฑ์ ์ด ์๋ค.
์ํํ(circular queue)
ํ์ฅ & ํ์ฉ
queue์ ๊ฐ๋ ์์ ์กฐ๊ธ ํ์ฅํ ์๋ฃ๊ตฌ์กฐ๋ค๋ก๋ ์์ชฝ์์ enqueue์ dequeue๊ฐ ๊ฐ๋ฅํ deque(double-ended queue)์ ์๊ฐ์์๊ฐ ์๋ ์ฐ์ ์์๊ฐ ๋์ ์์๋ก dequeueํ ์ ์๋ priority queue๊ฐ ์์.
ํ์ฉ ์์๋ก๋ ํ๋์ ์์์ ๊ณต์ ํ๋ ํ๋ฆฐํฐ
๋, CPU task scheduling
, Cache๊ตฌํ
, ๋๋น์ฐ์ ํ์(BFS)
Stack
stack์ ํ์ ์ ์ถ LIFO(Last In First Out)์ ์๋ฃ๊ตฌ์กฐ. ์๊ฐ๋ณต์ก๋๋ push O(1) , pop O(1)
ํ์ฉ ์์๋ ํ์ ํ๊ธฐ๋ฒ ์ฐ์ฐ
, ๊ดํธ ์ ํจ์ฑ ๊ฒ์ฌ
, ์น ๋ธ๋ผ์ฐ์ ๋ฐฉ๋ฌธ๊ธฐ๋ก(๋ค๋ก ๊ฐ๊ธฐ)
, ๊น์ด์ฐ์ ํ์(DFS)
๐ก stack์ด ๊ต์ฅํ ์ค์ํ ์๋ฃ๊ตฌ์กฐ์ด์ง๋ง, ๋ฉด์ ์์๋ stack์ ๋จ๋ ์ผ๋ก ์ง๋ฌธํ๋ ๊ฒฝ์ฐ๋ ๋ง์ด ์๋ค. ๋ฐ๋ผ์ Queue์ FIFO์ ๋์กฐ๋๋ LIFO๋ผ๋ ํน์ฑ๊ณผ, ํ์ฉ์์ ๊ธฐ์ตํ์.
LIFO
stack์ ์๊ฐ ์์์ ๊ฐ์ฅ ์ต๊ทผ์ ์ถ๊ฐํ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ํ์ ์ ์ถ LIFO(Last In First Out)ํ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ.
push & pop
- stack์์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ push๋ผ๊ณ ํ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ถ์ถ ํ๋ ๊ฒ์ pop์ด๋ผ๊ณ ํ๋ค.
- push์ ๊ฒฝ์ฐ stack์ ๋งจ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๋ฉด ์๋ฃ๋๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(1)
- ์ด์ ๋์ผํ๊ฒ pop์ ๊ฒฝ์ฐ๋ ๋งจ ๋ค์ ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ฉด ์๋ฃ ๋๊ธฐ ๋๋ฌธ์ O(1)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
- push์ pop์ ๋ชจ๋ stack์ top์ ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ๋ ํ์์ผ๋ก ๊ตฌํ
ํ์ฉ
stack์ ์ฌ๊ท์ ์ธ ํน์ง์ด ์์ด์ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐํ ๋ ์์ฃผ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ ํ์ฉ ์์๋ก๋ call stack
, ํ์ ํ๊ธฐ๋ฒ ์ฐ์ฐ
, ๊ดํธ ์ ํจ์ฑ ๊ฒ์ฌ
, ์น ๋ธ๋ผ์ฐ์ ๋ฐฉ๋ฌธ๊ธฐ๋ก(๋ค๋ก ๊ฐ๊ธฐ)
, ๊น์ด์ฐ์ ํ์(DFS)
Stack ๋ ๊ฐ๋ฅผ ์ด์ฉํ์ฌ Queue๋ฅผ ๊ตฌํ
๐ก stack ๋ ๊ฐ๋ฅผ ์ฌ์ฉํ์ฌ enqueue์ dequeue๋ฅผ ๊ตฌํํ๋ ๊ฒ์ ์ด์ ์ ๋ง์ถฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ๊ฐ๋ฅ
์ฌ์ค ์ด๋ฐ ๋ฌธ์ ๋ ๋ต์ด ๋ค์ํ๊ณ , ๋ต ์์ฒด๊ฐ ์ค์ํ๊ธฐ ๋ณด๋จ ๋ต์ ์ฐพ์๊ฐ๋ ๊ณผ์ ์ ๋ ์ค์ํ๊ฒ ๋ณด๊ธฐ ๋๋ฌธ์, ํ์ด๋ฅผ ์ธ์ฐ๊ธฐ๋ณด๋จ ์ ๊ทผ ๋ฐฉ์์ ์ฃผ์๊น๊ฒ ์๊ฐํ์
[Answer]
queue์ enqueue()๋ฅผ ๊ตฌํํ ๋ ์ฒซ ๋ฒ์งธ stack์ ์ฌ์ฉํ๊ณ , dequeue()๋ฅผ ๊ตฌํํ ๋ ๋ ๋ฒ์งธ stack์ ์ฌ์ฉํ๋ฉด queue๋ฅผ ๊ตฌํํ ์ ์๋ค.
ํธ์์ enqueue()์ ์ฌ์ฉํ stack์ instack์ด๋ผ๊ณ ๋ถ๋ฅด๊ณ dequeue()์ ์ฌ์ฉํ stack์ outstack์ด๋ผ๊ณ ํ์.
๋ ๊ฐ์ stack์ผ๋ก queue๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- enqueue() :: instack์ push()๋ฅผ ํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
- dequeue() ::
-
๋ง์ฝ outstack์ด ๋น์ด ์๋ค๋ฉด instack.pop() ์ ํ๊ณ outstack.push()๋ฅผ ํ์ฌ instack์์ outstack์ผ๋ก ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ฎ๊ฒจ ๋ฃ๋๋ค. ์ด ๊ฒฐ๊ณผ๋ก ๊ฐ์ฅ ๋จผ์ ์๋ ๋ฐ์ดํฐ๋ outstack์ top์ ์์นํ๊ฒ ๋๋ค.
-
outstack.pop()์ ํ๋ฉด ๊ฐ์ฅ๋จผ์ ์๋ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ ๋จผ์ ์ถ์ถ๋๋ค.(FIFO)
-
[์ฝ๋ ์์ฑ]
class Queue(object):
def __init__(self):
self.instack=[]
self.outstack=[]
def enqueue(self,element):
self.instack.append(element)
def dequeue(self):
if not self.outstack:
while self.instack:
self.outstack.append(self.instack.pop())
return self.outstack.pop()
Queue ๋ ๊ฐ๋ฅผ ์ด์ฉํ์ฌ Stack์ ๊ตฌํ
๐ก ๐ฏqueue ๋ ๊ฐ๋ฅผ ์ฌ์ฉํ์ฌ stack์ push์ pop๋ฅผ ๊ตฌํํ๋ ๊ฒ์ ์ด์ ์ ๋ง์ถฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด ๋๋ค. ๊ตฌํ ๋ฐฉ๋ฒ์ ์ธ์ฐ๊ธฐ๋ณด๋จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋๊ฐ๋ ๊ณผ์ ์ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ด ์ข๋ค.
[Answer]
ํธ์์ push()์ ์ฌ์ฉํ queue๋ q1์ด๋ผ๊ณ ๋ถ๋ฅด๊ณ pop()์ ์ฌ์ฉํ queue๋ฅผ q2๋ผ๊ณ ํ์.
๋ ๊ฐ์ queue๋ก stack์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- push() :: q1์ผ๋ก enqueue()๋ฅผ ํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
- pop() ::
-
q1์ ์ ์ฅ๋ ๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ 1 ์ดํ๋ก ๋จ์ ๋๊น์ง dequeue()๋ฅผ ํ ํ, ์ถ์ถ๋ ๋ฐ์ดํฐ๋ฅผ q2์ enqueue()ํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ์ฅ ์ต๊ทผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ฐ์ดํฐ๋ q2๋ก ์ฎ๊ฒจ์ง๋ค.
-
q1์ ๋จ์ ์๋ ํ๋์ ๋ฐ์ดํฐ๋ฅผ dequeue()ํด์ ๊ฐ์ฅ ์ต๊ทผ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํ๋ค.(LIFO)
-
๋ค์์ ์งํ๋ pop()์ ์์ ๊ฐ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์งํํ๊ธฐ ์ํด q1๊ณผ q2์ ์ด๋ฆ์ swapํ๋ค.
-
[์ฝ๋ ์์ฑ]
import queue
class Stack(object):
def __init__(self):
self.q1 = queue.Queue()
self.q2 = queue.Queue()
def push(self, element):
self.q1.put(element)
def pop(self):
while self.q1.qsize() > 1:
self.q2.put(self.q1.get())
temp = self.q1
self.q1 = self.q2
self.q2 = temp
return self.q2.get()
โญย Queue vs priority queue๋ฅผ ๋น๊ต
Queue ์๋ฃ๊ตฌ์กฐ๋ ์๊ฐ ์์์ ๋จผ์ ์ง์ด ๋ฃ์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋์ค๋ ์ ์ ์ ์ถ FIFO(First In First Out) ๊ตฌ์กฐ๋ก ์ ์ฅํ๋ ํ์. ์ด์ ๋ค๋ฅด๊ฒ ์ฐ์ ์์ํ(priority queue)๋ ๋ค์ด๊ฐ ์์์ ์๊ด์์ด ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ถ์ถ๋๋ค.
Queue์ operation ์๊ฐ๋ณต์ก๋๋ enqueue
O(1), dequeue
O(1)์ด๊ณ ,
Priority queue๋ push
O(logn) , pop
O(logn)
[ ๐ฏย TIP] ๐ก ์ฐ์ ์์ํ๋ฅผ ์ ๋ตํ๊ธฐ ์ํด์๋ ๊ตฌํ ๋ฐฉ๋ฒ๊ณผ operation์ ์๊ฐ๋ณต์ก๋๋ฅผ ์ ์ค๋ช ํ ์ ์์ด์ผ ํ๋ค.
์ฐ์ ์์ํ๋ฅผ ๊ตฌํํ๋ผ๊ณ ํ๋ฉด Heap์ ๊ตฌํ. Heap ์๋ฃ๊ตฌ์กฐ๋ ์ด์ง์์ ํธ๋ฆฌ๋ฅผ ํ์ฉํ๋ ๊ฒ์ด๊ณ ,๋ํ์ ์ธ operation์ ์๊ฐ๋ณต์ก๋๋ push
O(logn) , pop
O(logn)
๋ํ tree๊ฐ ๊ทธ๋ ค์ ธ ์๋ ์ํ์์ ์ต๋ํ, ์ต์ํ์ ์ฝ์ ๊ณผ ์ญ์ ์์ ์ด๋ป๊ฒ node๊ฐ ์ญ์ ๋๊ณ ์ฐ๊ฒฐ์ด ๋ณ๊ฒฝ๋๋์ง์ ๊ณผ์ ์ ๊ทธ๋ ค์ ์ค๋ช ๊ฐ๋ฅํด์ผ ํจ.
Heap
Heap์ ๊ทธ ์์ฒด๋ก ์ฐ์ ์์ํ(priority queue)์ ๊ตฌํ๊ณผ ์ผ์น
Heap์ ์์ ์ด์งํธ๋ฆฌ ๊ตฌ์กฐ์ ๋๋ค. Heap์ด ๋๊ธฐ ์ํ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.
-
๊ฐ node์ ์ ์ฅ๋ ๊ฐ์ child node๋ค์ ์ ์ฅ๋ ๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค(min heap)
โ root node์ ์ ์ฅ๋ ๊ฐ์ด ๊ฐ์ฅ ์์ ๊ฐ์ด ๋๋ค.
Heap๊ตฌํ
ํธ๋ฆฌ๋ ๋ณดํต Linked list๋ก ๊ตฌํ.
ํ์ง๋ง Heap์ tree์์๋ ๋ถ๊ตฌํ๊ณ array๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ. ๊ทธ ์ด์ ๋ ์๋ก์ด node๋ฅผ ํ์ โ๋ง์ง๋ง ์์นโ์ ์ถ๊ฐํด์ผ ํ๋๋ฐ, ์ด ๋ array๊ธฐ๋ฐ์ผ๋ก ๊ตฌํํด์ผ ์ด ๊ณผ์ ์ด ์์ํด์ง๊ธฐ ๋๋ฌธ์ด๋ค.
- ๊ตฌํ์ ํธ์๋ฅผ ์ํด array์ 0๋ฒ ์งธ index๋ ์ฌ์ฉํ์ง ์์ต๋๋ค.
- ์์ ์ด์งํธ๋ฆฌ์ ํน์ฑ์ ํ์ฉํ์ฌ array์ index๋ง์ผ๋ก ๋ถ๋ชจ ์์๊ฐ์ ๊ด๊ณ๋ฅผ ์ ์.
- $n$๋ฒ ์งธ node์ left child node = $2n$
- $n$๋ฒ ์งธ node์ right child node = $2n+1$
- $n$๋ฒ ์งธ node์ parent node = $n/2$
Heap push - O(logn)
heap tree์ ๋์ด๋ logN
push()
๋ฅผ ํ์ ๋, swapํ๋ ๊ณผ์ ์ด ์ต๋ $logN$๋ฒ ๋ฐ๋ณต๋๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(logn)
Heap pop - $O(logn)$
pop()
์ ํ์ ๋, swapํ๋ ๊ณผ์ ์ด ์ต๋ $logN$๋ฒ ๋ฐ๋ณต๋๊ธฐ ๋๋ฌธ์ ์๊ฐ๋ณต์ก๋๋ O(logn)
-
๊ฐ node์ ์ ์ฅ๋ ๊ฐ์ child node๋ค์ ์ ์ฅ๋ ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค(max heap)
โ root node์ ์ ์ฅ๋ ๊ฐ์ด ๊ฐ์ฅ ํฐ ๊ฐ์ด ๋๋ค.
Hash table & BST(Binary Search Tree)
โญโญBST
[ํต์ฌ]
์ด์งํ์ํธ๋ฆฌ(Binary Search Tree; BST)๋ ์ ๋ ฌ๋ tree.
์ด๋ node๋ฅผ ์ ํํ๋ ํด๋น node์ left subtree์๋ ๊ทธ node์ ๊ฐ๋ณด๋ค ์์ ๊ฐ๋ค์ ์ง๋ node๋ค๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๊ณ , node์ right subtree์๋ ๊ทธ node์ ๊ฐ๋ณด๋ค ํฐ ๊ฐ๋ค์ ์ง๋ node๋ค๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ binary tree
๊ฒ์๊ณผ ์ ์ฅ, ์ญ์ ์ ์๊ฐ๋ณต์ก๋๋ ๋ชจ๋ O(logn)์ด๊ณ , worst case๋ ํ์ชฝ์ผ๋ก ์น์ฐ์น tree๊ฐ ๋์ ๋ $O(n)$
[ ๐ฏย TIP]
๐ก BST๋ ์ ์ฅ๊ณผ ๋์์ ์ ๋ ฌ์ ํ๋ ์๋ฃ๊ตฌ์กฐ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋ ์ผ์ ํ ๊ท์น์ ๋ฐ๋ผ ์ ์ฅ.
BST
BST ์กฐ๊ฑด
- root node์ ๊ฐ๋ณด๋ค ์์ ๊ฐ์ left subtree์, ํฐ ๊ฐ์ right subtree์ ์๋ค.
- subtree๋ 1๋ฒ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.(Recursive)
search
O(logn)
์ฐธ์กฐ : ๊ฐ๋ฐ๋จ๋ ธ์จ ์๋ฃ๊ตฌ์กฐ
Leave a comment