13-pu2rile

[pu2rile]

🔗 문제 링크

백준 - 후위 표기식

✔️ 소요된 시간

30분

✨ 수도 코드

👀 문제 선정 이유

준서 님이 이전 pr에서 코멘트로 추천해 주셔서 냅다 그냥 앞뒤 안 재고 바로 풀어 봤습니다!!
(저 이런 거 좋아요... 자주 소통해요...)

문제 요약

중위 표기식이 주어졌을 때 후위 표기식으로 고치는 프로그램 작성

‼️‼️‼️ 아니 근데 글쎄 ‼️‼️‼️

문제를 한번 슥 보니까 작년에 편입 준비하면서 자료구조 공부할 때 열심히 풀었던 문제더라구요??

증거 사진

그래서... 의도치 않게 날먹... ^^........ 하려다가! 작년에는 C로만 풀어 봐서 이번에는 파이썬으로 풀어 봤습니다 ㅎㅎ

🔍 수식?

• 수식의 표현 방법 3가지

  • 전위(Prefix), 중위(Infix), 후위(Postfix)
  

• 그래서 이걸 언제 사용하는 건데

  • 컴퓨터에서 수식을 계산할 때!
  • 중위 표기식 -> 후위 표기식 -> 계산
  • ex. 2 + 3 * 4 -> 234*+ -> 14

참고) 후위 표기식의 계산

겉핥기

수식을 왼쪽에서 오른쪽으로 스캔하여 피연산자이면 스택에 저장하고, 연산자이면 필요한 수만큼의 피연산자를 스택에서 꺼내 연산을 실행하고 연산의 결과를 다시 스택에 저장

예) 82/3-32*+

중위 표기식 -> 후위 표기식 과정

1. 연산자 우선순위 확인
   • 각 연산자는 우선순위가 있음 -> * 와 / 는 + 와 - 보다 우선순위가 높음
2. 피연산자 출력
   • 수식에서 숫자나 변수와 같은 피연산자는 바로 출력
3. 연산자 처리
   • 연산자는 스택에 저장
   • 이때, 스택의 상단에 있는 연산자의 우선순위가 현재 연산자보다 크거나 같으면 스택에서 연산자를 꺼내서 출력
   • 그런 다음 현재 연산자를 스택에 넣음
4. 괄호 처리
   • 여는 괄호 ( 는 무조건 스택에 넣음
   • 닫는 괄호 ) 가 나오면 스택에서 여는 괄호 ( 가 나올 때까지 연산자를 꺼내서 출력
   • 여는 괄호( 는 출력하지 않고 버리기
5. 남은 연산자 출력
   • 수식이 끝나면 스택에 남아 있는 모든 연산자를 꺼내서 출력

📍 그림으로 보기

💻 최종 코드

c언어로 보기

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STACK_SIZE 100
#define MAX_TEXT_SIZE 100 // 중위 표기 수식의 최대 길이

typedef char element;

typedef struct {
    element data[MAX_STACK_SIZE];
    int top;
} StackType;

// 스택 초기화 함수
void init_stack(StackType *s) {
    s->top = -1;
}

// 공백 상태 검출 함수
int is_empty(StackType *s) {
    return (s->top == -1);
}

// 포화 상태 검출 함수
int is_full(StackType *s) {
    return (s->top == (MAX_STACK_SIZE - 1));
}

// 삽입 함수
void push(StackType *s, element item) {
    if (is_full(s)) {
        fprintf(stderr, "스택 포화 에러\n");
        return;
    } else {
        s->data[++(s->top)] = item;
    }
}

// 삭제 함수
element pop(StackType *s) {
    if (is_empty(s)) {
        fprintf(stderr, "스택 공백 에러\n");
        exit(1);
    } else {
        return s->data[(s->top)--];
    }
}

// 스택의 top에 있는 요소를 반환하는 함수 (삭제하지 않음)
element peek(StackType *s) {
    if (is_empty(s)) {
        fprintf(stderr, "스택 공백 에러\n");
        exit(1);
    } else {
        return s->data[s->top];
    }
}

// 연산자의 우선 순위를 반환
int prec(char op) {
    switch (op) {
        case '(': case ')': return 0;
        case '+': case '-': return 1;
        case '*': case '/': return 2;
    }
    return -1;
}

// 중위 표기 수식 -> 후위 표기 수식
void infix_to_postfix(char exp[]) {
    int i = 0;
    char ch, top_op;
    int len = strlen(exp);
    StackType s;

    init_stack(&s); // 스택 초기화
    for (i = 0; i < len; i++) {
        ch = exp[i];
        switch (ch) {
            case '+': case '-': case '*': case '/': // 연산자
                // 스택에 있는 연산자의 우선순위가 더 크거나 같으면 출력
                while (!is_empty(&s) && (prec(ch) <= prec(peek(&s))))
                    printf("%c", pop(&s));
                push(&s, ch);
                break;
            case '(':// 왼쪽 괄호
                push(&s, ch);
                break;
            case ')':// 오른쪽 괄호
                top_op = pop(&s);
                // 왼쪽 괄호를 만날 때까지 출력
                while (top_op != '(') {
                    printf("%c", top_op);
                    top_op = pop(&s);
                }
                break;
            default:    // 피연산자
                printf("%c", ch);
                break;
        }
    }
    while (!is_empty(&s)) // 스택에 저장된 연산자들 출력
        printf("%c", pop(&s));
}

int main(void) {
    char s[MAX_TEXT_SIZE];
    scanf("%s", s);
    infix_to_postfix(s);
    printf("\n");
    return 0;
}

파이썬으로 보기

MAX_STACK_SIZE = 100
MAX_EXPR_SIZE = 100

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return not self.items

    def push(self, item):
        if len(self.items) >= MAX_STACK_SIZE:
            raise OverflowError("스택 포화 에러: 최대 크기 초과")
        self.items.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("스택 공백 에러")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("스택 공백 에러")
        return self.items[-1]

def prec(op):
    if op in {'+', '-'}:
        return 1
    elif op in {'*', '/'}:
        return 2
    else:
        return 0

def infix_to_postfix(exp):
    if len(exp) > MAX_EXPR_SIZE:
        raise ValueError("수식 길이 초과 에러: 최대 길이 초과")
    
    s = Stack()
    postfix = []
    for ch in exp:
        if ch.isalnum():  # 피연산자 (숫자, 문자 등)
            postfix.append(ch)
        elif ch == '(':
            s.push(ch)
        elif ch == ')':
            while not s.is_empty() and s.peek() != '(':
                postfix.append(s.pop())
            s.pop()  # '(' 버림
        else:  # 연산자
            while not s.is_empty() and prec(ch) <= prec(s.peek()):
                postfix.append(s.pop())
            s.push(ch)

    while not s.is_empty():  # 스택에 남아 있는 모든 연산자를 출력
        postfix.append(s.pop())

    return ''.join(postfix)

def main():
    expr = input()
    postfix_expr = infix_to_postfix(expr)
    print(postfix_expr)

if __name__ == "__main__":
    main()

📚 새롭게 알게된 내용

준서 님 덕분에 추억 팔이도 하고 복습도 하고 너무 재미있었습니다!! 다음에도 추천해 줄 만한 문제 보이면 언제든지 던져 주세요~~!!

[oesnuj]

오우 추천해드린 문제를 바로 풀어주셨네요~ 자주 추천드려보겠습니닷!!

스택을 직접 구현해서 푸셨네요!!
자료구조를 사용할때 라이브러리로 바로 쓰기 보다는 내부 원리를 정확히 알고 사용하면 좋죠!
그래서 직접 구현해서 풀어보는 것도 정말 좋은 방법이라고 생각해요👏👏👏

저는 예전에 풀어봤었는 데 큐랑 스택를 이용해서 풀었었습니다!
큐는 기존 중위 표기수식을 저장해서 앞에서부터 처리하기 위해 사용해봤습니다.
스택은 stack 라이브러리를 사용했습니다.
주요 로직이 도현님 풀이와 거의 동일 한 것 같네요. 이번 PR도 수고하셨습니다👍

#include <iostream>
#include <string>
#include <stack>
#include <queue>
using namespace std;

int Prec(char c)  //연산자 우선순위 정의
{
	if (c == '/' || c == '*')
		return 2;
	else if (c == '+' || c == '-')
		return 1;
	else
		return -1; // '('는 우선순위가 아주 낮은 것으로 처리, ')' 닫는 괄호를 만날때까지 남겨두기 위함
}

int main()
{
    stack <char> s;
    queue <char> q;
    string infix;
    cin >> infix;
    for (int i = 0; i < infix.length(); i++)
    {
        q.push(infix[i]);
    }

    while (!q.empty())
    {
		char c = q.front();
		q.pop();
		if (c >= 'A' && c <= 'Z')
		{
			cout << c;
		}
		else if (c == '(')
		{
			s.push(c);
		}
		else if (c == ')')
		{
			while (s.top() != '(')
			{
				cout << s.top();
				s.pop();
			}
			s.pop();
		}
		else //연산자가 나왔을때 스택에 있는 것보다  작거나 같으면 pop
		{
			while (!s.empty() && Prec(s.top()) >= Prec(c))
			{
				cout << s.top();
				s.pop();
			}
			s.push(c);
		}
    }
	while (!s.empty())
	{
		cout << s.top();
		s.pop();
	}
    return 0;
}