HW)
파이썬으로 데이터를 처리할 때, 데이터 처리 방식에 대한 논리적인 구조를 이해하는 것이 중요하다. 특히 자료구조 이론으로 스택(Stack)과 큐(Queue)에 대해서 이해해야 한다. 아래에 그림과 표로써, 스택과 큐의 개념과, 차이점을 정리하고 파이썬으로 구동 방식의 차이 또한 구현해보자.
우선, 빈 메모리에 데이터 3가지 요소(ex, 대한, 민국, 만세)가 차례로 쌓이고 비워지는 상황을 예로 비교해보자.
> Stack은 LIFO 방식으로 구동하며 목록에 들어온 마지막 요소(Last-in)가 가장 먼저 제거된다(First-Out).
- push : 요소가 순서대로 쌓이도록 함. : [(empty)] → [대한(peek)] → [대한, 민국(peek)] → [대한, 민국, 만세(peek)]
- pop : LIFO 방식으로 제거되도록 함. : [대한, 민국, 만세(peek)] → [대한, 민국(peek)] → [대한(peek)] → [(empty)]
> Queue는 FIFO 방식으로 구동하며 목록에 가장 먼저 들어온 요소(First-in)가 가장 먼저 제거된다(First-Out).
- enqueue : 요소가 순서대로 쌓이도록 함. : [(empty)] → [대한(peek)] → [대한(peek), 민국] → [대한(peek), 민국, 만세]
- dequeue : FIFO 방식으로 제거되도록 함. : [대한(peek), 민국, 만세] → [민국(peek), 만세] → [만세(peek)] → [(empty)]
[그림] 메모리에서 스택(Stack)과 큐(Queue)의 데이터 처리 방식의 차이점 비교
스택은 가장 늦게 참석한 순서대로 먼저 탈락하는 마치 커트라인 넘기와 비슷하고, 큐는 가장 먼저 참석한 순서대로 빠져나가는 일렬 줄서기와 비슷하다. 이와 같은 내용으로, 스택과 큐의 차이점을 구동 방식, 주요 매서드, 주 사용 예시를 기준으로 아래 표에 비교하였다.
| 비교 항목 |
스택(Stack) | 큐(Queue) |
| 구동 방식 |
> LIFO 방식 가장 나중에 들어온 것이 ; (Last-in) 가장 먼저 나간다 ; (First-out) |
> FIFO 방식 가장 먼저 들어온 것이 ; (First-in) 가장 먼저 나간다 ; (First-out) |
| 주요 매서드 |
push : 넣기 pop : 빼기 (나중에 들어간 것 부터) |
enqueue : 넣기 dequeue : 빼기 (먼저 들어간 것 부터) |
| 주 사용 예시 |
되돌리기(Undo) : 가장 최근에 한 작업을 바로 취소함. 괄호 검사 - [{( , )}] 재귀 : 호출된 함수가 스택에서 반환되며 거꾸로 빠짐 |
대기열, 작업 순서 처리 : 먼저 도착한 순서대로 처리함. BFS 탐색* : 시작점에서 가까운 곳부터 차례대로 확장 *효과 : 가중치가 없는 그래프/격자에서 최단 거리를 보장. |
그러면, 파이썬으로 스택과 큐의 구동 방식을 구현해보자.
먼저 Stack과 Queue를 class 정의를 활용하여 요소를 넣고 빼는 것에 같은 기능을 수행하도록 하고, peak에 대해서만 각각 요소의 맨 위(Top, 즉 가장 뒷 요소)와 맨 앞(Front (or Bottom), 즉 가장 앞 요소)를 구분할 수 있게 하자.
Class - 스택(Stack)
# ==========================================================
# 1. Stack(스택) - class 정의
# ==========================================================
class Stack:
def __init__(self):
self.data = []
def push(self, item):
self.data.append(item)
print(f"'{item}' 을(를) 스택에 넣었습니다.")
def pop(self):
if self.is_empty():
print("⚠️ 스택이 비어 있습니다.")
return None
item = self.data.pop()
print(f"'{item}' 을(를) 스택에서 꺼냈습니다.")
return item
def peek(self):
if self.is_empty():
print("⚠️ 스택이 비어 있어 맨 위 원소가 없습니다.")
return None
top = self.data[-1]
print(f"맨 위(Top): '{top}'")
return top
def is_empty(self):
return len(self.data) == 0
def show(self):
print("현재 스택 상태:", self.data)
Class - 큐(Queue)
# ==========================================================
# 2. Queue(큐) - class 정의
# ==========================================================
class Queue:
def __init__(self):
self.data = []
def enqueue(self, item):
self.data.append(item)
print(f"'{item}' 을(를) 큐에 넣었습니다.")
def dequeue(self):
if self.is_empty():
print("⚠️ 큐가 비어 있습니다.")
return None
item = self.data[0]
del self.data[0]
print(f"'{item}' 을(를) 큐에서 꺼냈습니다.")
return item
def peek(self):
if self.is_empty():
print("⚠️ 큐가 비어 있어 맨 앞 원소가 없습니다.")
return None
front = self.data[0]
print(f"맨 앞(Front): '{front}'")
return front
def is_empty(self):
return len(self.data) == 0
def show(self):
print("현재 큐 상태:", self.data)
그리고 스택 또는 큐를 선택한 후, 데이터(요소)를 넣고, 꺼내는 것과 현재 목록 상태 및 peak 요소와 empty 여부를 구분할 수 있도록 해보자. 각 input에 입력할 키(key: S, Q, E, 1, 2, 3, 4, 5)를 아래와 같이 정해보자.
| 구분 | S : 스택(Stack) 사용하기 | Q : 큐(Queue) 사용하기 | 출력 예시 |
| 1 | 데이터(요소) 넣기 : push | 데이터(요소) 넣기 : enqueueu | "대한을 스택(or 큐)에 넣었습니다." |
| 2 | 데이터 꺼내기 : pop (LIFO 방식) | 데이터 꺼내기 : dequeue (FIFO 방식) | "대한을 스택(or 큐)에서 꺼냈습니다." |
| 3 | 맨 위 보기 : peak | [대한] or [민국] or [만세] | |
| 4 | (목록이) 비었는지 확인 : is_empty | True or False | |
| 5 | 현재 (목록) 상태 보기 | [ ] or [대한] or ... or [대한,민국,만세] | |
| E : 프로그램 종료하기 | "프로그램을 종료합니다" | ||
Stack(LIFO) vs Queue(FIFO) - 스택과 큐의 서로 다른 구동 방식을 구현해보자.
# ==========================================================
# 3. Stack & Queue - 실습 예제 (실행)
# ==========================================================
stack = Stack()
queue = Queue()
while True:
print("\n==== 자료구조 연습 프로그램 ====")
print("S. 스택 사용하기") # S <-> Stack
print("Q. 큐 사용하기") # Q <-> Queue
print("E. 종료") # E <-> End
choice = input("메뉴 번호를 입력하세요: ")
if choice == "S": # S <-> Stack
print("\n--- 스택 메뉴 ---")
print("1) 데이터 넣기(push)")
print("2) 데이터 꺼내기(pop)")
print("3) 맨 위 보기(peek)")
print("4) 비었는지 확인(is_empty)")
print("5) 현재 상태 보기")
sub = input("원하는 작업을 선택하세요: ")
if sub == "1":
item = input("추가할 데이터를 입력하세요: ")
stack.push(item)
elif sub == "2":
stack.pop()
elif sub == "3":
stack.peek()
elif sub == "4":
print("스택이 비었는가? →", stack.is_empty())
elif sub == "5":
stack.show()
else:
print("올바르지 않은 선택입니다.")
elif choice == "Q":
print("\n--- 큐 메뉴 ---")
print("1) 데이터 넣기(enqueue)")
print("2) 데이터 꺼내기(dequeue)")
print("3) 맨 앞 보기(peek)")
print("4) 비었는지 확인(is_empty)")
print("5) 현재 상태 보기")
sub = input("원하는 작업을 선택하세요: ")
if sub == "1":
item = input("추가할 데이터를 입력하세요: ")
queue.enqueue(item)
elif sub == "2":
queue.dequeue()
elif sub == "3":
queue.peek()
elif sub == "4":
print("큐가 비었는가? →", queue.is_empty())
elif sub == "5":
queue.show()
else:
print("올바르지 않은 선택입니다.")
elif choice == "E":
print("프로그램을 종료합니다. 👋")
break
else:
print("⚠️ 잘못된 입력입니다. 다시 선택하세요.")
========================
첫번째로, 스택(S)을 해보자.
처음에는 메모리에 아무것도 없는 상태이다.
▷ 입력 = S, 5, S, 4, S, 3
현재 스택 상태 = [ ]
스택이 비었는가 = True
맨 위 보기(peak(Top)) = 스택이 비어 있어 맨 위 원소가 없다.
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: []
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
스택이 비었는가? → True
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
⚠️ 스택이 비어 있어 맨 위 원소가 없습니다.
'''
다음으로(push) 메모리에 '대한'을 넣었다.
▷ 입력 = S, 1, S, 5
추가할 데이터 : 대한 → '대한' 을 스택에 넣었습니다.
현재 스택 상태 = ['대한'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 대한
'대한' 을(를) 스택에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: ['대한']
'''
다음으로(push) 메모리에 '민국'을 추가로 넣었다.
▷ 입력 = S, 1, S, 5
추가할 데이터 : 민국 → '민국' 을 스택에 넣었습니다.
현재 스택 상태 = ['대한', '민국'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 민국
'민국' 을(를) 스택에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: ['대한', '민국']
'''
다음으로(push) 메모리에 '만세'를 추가로 넣었다.
▷ 입력 = S, 1, S, 5
추가할 데이터 : 만세 → '만세' 를 스택에 넣었습니다.
현재 스택 상태 = ['대한', '민국', '만세'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 만세
'만세' 을(를) 스택에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: ['대한', '민국', '만세']
'''
여기에서, 목록의 empty 여부와 맨 위 보기 peak(Top)을 확인해보자.
▷ 입력 = S, 4, S, 3
스택이 비었는가? → False (현재 스택 상태가 ['대한', '민국', '만세'] 이기 때문이다.)
맨 위(Top) = '만세' → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
스택이 비었는가? → False
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 위(Top): '만세'
'''
다음으로(pop) 메모리에서 '만세'를 꺼낸다.
▷ 입력 = S, 2, S, 5, S, 3
꺼낼 데이터 : 만세 → '만세' 를 스택에서 꺼냈습니다.
현재 스택 상태 = ['대한', '민국'].
맨 위(Top) = '민국' → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'만세' 을(를) 스택에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: ['대한', '민국']
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 위(Top): '민국'
'''
다음으로(pop) 메모리에서 '민국'을 꺼낸다.
▷ 입력 = S, 2, S, 5, S, 3
꺼낼 데이터 : 민국 → '민국' 을 스택에서 꺼냈습니다.
현재 스택 상태 = ['대한'].
맨 위(Top) = '대한' → OK ('대한' 하나만 남았기 때문에 peak(Top)가 요소 자신이 된다.)
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'민국' 을(를) 스택에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: ['대한']
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 위(Top): '대한'
'''
다음으로(pop) 메모리에서 '대한'을 꺼낸다.
▷ 입력 = S, 2, S, 5, S, 4, S, 3
꺼낼 데이터 : 대한 → '대한' 을 스택에서 꺼냈습니다.
현재 스택 상태 = [ ]
스택이 비었는가? → True
맨 위(Top) = !! 스택이 비어 있어 맨 위 요소가 없습니다. → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'대한' 을(를) 스택에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 스택 상태: []
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
스택이 비었는가? → True
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: S
--- 스택 메뉴 ---
1) 데이터 넣기(push)
2) 데이터 꺼내기(pop)
3) 맨 위 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
⚠️ 스택이 비어 있어 맨 위 원소가 없습니다.
'''
마지막으로 스택 class 실행을 종료한다.
▷ 입력 = E
프로그램을 종료합니다.
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: E
프로그램을 종료합니다. 👋
'''
========================
두번째로, 큐(Q)를 해보자.
처음에는 메모리에 아무것도 없는 상태이다.
▷ 입력 = Q, 5, Q, 4, Q, 3
현재 큐 상태 = [ ]
큐가 비었는가 = True
맨 앞 보기(peak(Front)) = 큐가 비어 있어 맨 앞 원소가 없다.
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: []
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
큐가 비었는가? → True
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
⚠️ 큐가 비어 있어 맨 앞 원소가 없습니다.
'''
다음으로(enqueue) 메모리에 '대한'을 넣었다.
▷ 입력 = Q, 1, Q, 5
추가할 데이터 : 대한 → '대한' 을 큐에 넣었습니다.
현재 큐 상태 = ['대한'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 대한
'대한' 을(를) 큐에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: ['대한']
'''
다음으로(enqueue) 메모리에 '민국'을 넣었다.
▷ 입력 = Q, 1, Q, 5
추가할 데이터 : 민국 → '민국' 을 큐에 넣었습니다.
현재 큐 상태 = ['대한', '민국'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 민국
'민국' 을(를) 큐에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: ['대한', '민국']
'''
다음으로(enqueue) 메모리에 '만세'를 넣었다.
▷ 입력 = Q, 1, Q, 5
추가할 데이터 : 만세 → '만세' 를 큐에 넣었습니다.
현재 큐 상태 = ['대한', '민국', '만세'].
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 1
추가할 데이터를 입력하세요: 만세
'만세' 을(를) 큐에 넣었습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: ['대한', '민국', '만세']
'''
여기에서, 목록의 empty 여부와 맨 위 보기 peak(Front)을 확인해보자.
▷ 입력 = Q, 4, Q, 3
큐가 비었는가? → False (현재 큐 상태가 ['대한', '민국', '만세'] 이기 때문이다.)
맨 앞(Front) = '대한' → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
큐가 비었는가? → False
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 앞(Front): '대한'
'''
다음으로(dequeue) 메모리에서 '대한'을 꺼낸다.
▷ 입력 = Q, 2, Q, 5, Q, 3
꺼낼 데이터 : 대한 → '대한' 을 큐에서 꺼냈습니다.
현재 큐 상태 = ['민국', '만세'].
맨 앞(Front) = '민국' → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'대한' 을(를) 큐에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: ['민국', '만세']
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 앞(Front): '민국'
'''
다음으로(dequeue) 메모리에서 '민국'을 꺼낸다.
▷ 입력 = Q, 2, Q, 5, Q, 3
꺼낼 데이터 : 민국 → '민국' 을 큐에서 꺼냈습니다.
현재 큐 상태 = ['만세'].
맨 앞(Front) = '만세' → OK ('민국' 하나만 남았기 때문에 peak(Front)가 요소 자신이 된다.)
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'민국' 을(를) 큐에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: ['만세']
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
맨 앞(Front): '만세'
'''
다음으로(dequeue) 메모리에서 '대한'을 꺼낸다.
▷ 입력 = Q, 2, Q, 5, Q, 4, Q, 3
꺼낼 데이터 : 만세 → '만세' 를 큐에서 꺼냈습니다.
현재 큐 상태 = [ ].
큐이 비었는가? → True
맨 앞(Front) = !! 큐가 비어 있어 맨 위 요소가 없습니다. → OK
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 2
'만세' 을(를) 큐에서 꺼냈습니다.
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 5
현재 큐 상태: []
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 4
큐가 비었는가? → True
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: Q
--- 큐 메뉴 ---
1) 데이터 넣기(enqueue)
2) 데이터 꺼내기(dequeue)
3) 맨 앞 보기(peek)
4) 비었는지 확인(is_empty)
5) 현재 상태 보기
원하는 작업을 선택하세요: 3
⚠️ 큐가 비어 있어 맨 앞 원소가 없습니다.
'''
마지막으로 큐 class 실행을 종료한다.
▷ 입력 = E
프로그램을 종료합니다.
'''
==== 자료구조 연습 프로그램 ====
S. 스택 사용하기
Q. 큐 사용하기
E. 종료
메뉴 번호를 입력하세요: E
프로그램을 종료합니다. 👋
'''
이와 같이, Stack와 Queue의 구동 방식에 대한 차이를 class 정의를 활용하여 비교 체감하였다. 두 구동 방식의 차이점인 LIFO와 FIFO를 이해하고, 특히 각 구동 방식이 데이터(요소) 중에서 peak를 어떻게 다르게 취급하는지를 이해할 수 있었다.
필자는 ChatGPT5 에게 체계적으로 Q&A를 반복하면서, 위와 같이 원하는 코드를 검증하면서 완성할 수 있었다. 앞으로 파이썬에 능숙해지면, 결과를 좀 더 간단하고 가독성 좋게 출력할 수도 있을 것 같다.
즐거운 파이썬~ 즐 파이씽~
[주의] 내용에 오류가 있을 수 있습니다.
'[Code] Study & Practice' 카테고리의 다른 글
| [Python] 자료 구조4 - 이진 트리(Binary Tree)의 개념, 구조, 규칙 (0) | 2025.11.01 |
|---|---|
| [Python] 자료 구조3 - Hash table의 개념과 index 충돌 해결 방식 비교 (0) | 2025.10.30 |
| [Python] 자료 구조2 - Single & Double Linked List(연결 리스트)의 개념과 차이점 (1) | 2025.10.28 |
| [Python] 메모리(RAM)와 변수(Variable)의 개념. (0) | 2025.10.22 |
| [Python] 2진수의 소수점 연산 불일치와 연산 허용 오차 범위. (0) | 2025.10.21 |