C 스택 질문입니다.

// @brif 
// step 1. 중위 표기법으로 수식을 입력받은 후 스택을 이용하여 후위 표기법으로 변환합니다.
// step 2. 후위 표기법으로 변환된 수식을 스택에 담아 연산합니다.
 
#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
 
// 스택의 각 요소들(숫자 or 연산자)의 크기
// 몇 자리의 숫자가 들어올지 알 수 없으므로,
// 255로 지정하였습니다.
#define MAX_SIZE 255
 
// 스택을 문자열 배열로 선언합니다.(전역변수)
char *g_pchStack[MAX_SIZE];	
int  g_nSize;
int  g_nTop;				
 
// 필요한 함수들을 선언합니다.
void InitStack(int nSize);		// 스택 초기화 함수
int  IsFull();					// 스택이 꽉 찼는지 확인하는 함수
int  IsEmpty();					// 스택이 비었는지 확인하는 함수
void Push( char *chdata);		// push 함수
char *Pop();					// Pop 함수
void DisposeStack();			// 스택에 할당한 메모리 해제 함수
 
int main(void)
{
	// =================================================================
	// step 1. 중위 표기법을 후위 표기법으로 변환하기
	int i;
 
	// 입력할 값들을  담을 변수
	char chInput[MAX_SIZE] ={0,};
	char pchtempinput[MAX_SIZE] = {0,};
 
	// 스택을 초기화 할 때 스택의 크기를 결정하기 위해 사용할 변수
 
	// 연산자의 개수
	int nOperationNum = 0;
 
	// 연산자 + 숫자의 개수
	int nFullNum = 0;
 
	// PUSH 할 값을 입력받습니다.
	scanf("%s", chInput);
 
	//-----------------------------------------------------
	// 입력한 값을 숫자, 연산자로 나누기 위해 공백이라는 구분자를 넣어
	// pchtempinput 이라는 문자 배열에 넣어줍니다.
	// 예를 들어, 12+34라는 값이 입력되었다면
	// pchtempinput[0] = 1
	// pchtempinput[1] = 2
	// pchtempinput[2] = " "(공백)
	// pchtempinput[3] = +
	// pchtempinput[4] = " "(공백)
	// pchtempinput[5] = 3
	// pchtempinput[6] = 4
	// 와 같은 값이 들어갑니다.. 
	for (i = 0; i<strlen(chInput); i++)
	{
		// 입력된 값이 숫자라면,
		if (chInput[i] > 47 && chInput[i] < 58)
		{
			// 숫자가 담깁니다.
			pchtempinput[strlen(pchtempinput)] = chInput[i];
		}
		else
		{
			// 연산자가 나오면 "공백" 연산자 "공백" 으로 처리하여 배열에 담깁니다.
			pchtempinput[strlen(pchtempinput)] = 0x20;
			pchtempinput[strlen(pchtempinput)] = chInput[i];
			pchtempinput[strlen(pchtempinput)] = 0x20;
 
			// 연산자의 개수를 세기 위한 변수 ++
			nOperationNum++;
		}
	}
	//-------------------------------------------------------
 
 
	//-------------------------------------------------------
	// 스택 초기화(동적)
 
	// 연산자가 담길 스택의 크기는 (연산자의 개수)로 초기화 합니다.
	// 연산자가 다 담길 일이 거의 없지만,
	// 다 담길 경우도 배재할 수 없으므로 연산자의 개수로 초기화
	InitStack(nOperationNum);
	//-------------------------------------------------------
 
 
	//-------------------------------------------------------
	// 구분자인 공백을 이용하여 숫자, 연산자를 분리합니다.
	// 이후 숫자는 배열에, 연산자는 스택에 넣습니다.
	// 숫자는 배열에 순차적으로 담기고, 수식은 스택에 일정한 규칙대로 담기게 됩니다.
	// 1. +,- 는 스택에 있는 모든 기호를 꺼내어 배열에 보관한 후 자신을 스택에 Push
	// 2. *,/ 는 스택에 있는 것을 꺼내어 자신과 우선순위를 비교하여 순위가 낮으면 
	// 꺼낸 연산자를 스택에 다시 Push하고 자기 자신도 Push합니다.
	// 연산자의 우선순위는 "*" = "/" > "+" = "-"
 
	// 잘린 문자열이 담길 변수
	char *ptr = strtok(pchtempinput, " ");
 
	// 연산자가 임시로 담겨질 문자열(char*) 변수 선언
	char *pchTempOperation;
	pchTempOperation = (char*)malloc(MAX_SIZE);
	memset(pchTempOperation, 0, MAX_SIZE);
 
	// 후위표기법으로 변환된 수식이 담겨질 문자열 배열(char*[]) 변수 선언
	// 이 배열의 크기는 숫자 + 연산자 모두가 담길수 있는 크기로 메모리가 할당되어야 함
	// 전체 개수를 구하려면 (연산자의 개수 *2) +1 을 하면 된다.
	nFullNum = (nOperationNum*2) +1;
	char  *chPostfixBuf[MAX_SIZE];
	for (int i = 0; i < nFullNum; i++)
	{
		chPostfixBuf[i] = (char*)malloc(MAX_SIZE);
		memset(chPostfixBuf[i], 0, MAX_SIZE);
	}
 
	// 후위표기법 수식이 담겨질 배열의 크기를 알기 위해 선언하는 변수
	int nPostfixBufSIze = 0;
 
	while (1)
	{
		// 수식이 끝일 경우..
		if(ptr == NULL)
		{
			// 스택의 연산자 전부 꺼내어 배열에 보관
			while(1)
			{
				// 스택이 비어있는 경우 반복문 빠져나가기
				if(IsEmpty() == 0)
				{
					break;
				}
				pchTempOperation = Pop();
				chPostfixBuf[nPostfixBufSIze] = pchTempOperation;
				nPostfixBufSIze++;
			}
			break;
		}
 
		//printf("%s\n", ptr);          // 자른 문자열 출력(잘 잘렸는지 테스트용)
 
		if (strcmp(ptr, "*")==0 || strcmp(ptr, "/")==0 )
		{
			// 스택이 비어있을 경우 그냥 담는다.
			if(IsEmpty() == 0)
			{
				Push(ptr);
			}
			// 스택에 값이 있을 경우
			else 
			{
				// 꺼낸다.
				pchTempOperation = Pop();
 
				// 값의 우선순위가 낮은 경우
				if(strcmp(pchTempOperation, "+")==0||strcmp(pchTempOperation, "-")==0)
				{
					// 꺼낸 것을 다시 넣고, 자기 자신도 넣는다.
					Push(pchTempOperation);
					Push(ptr);
				}
				// 값의 우선순위가 같은 경우
				else if(strcmp(pchTempOperation, "*")==0||strcmp(pchTempOperation, "/")==0)
				{
					// 꺼낸 것을 배열에 넣고, 자기 자신을 스택에 넣는다.
					chPostfixBuf[nPostfixBufSIze] = pchTempOperation;
					Push(ptr);
					nPostfixBufSIze++;
				}
			}
		}
		else if(strcmp(ptr, "+")==0 || strcmp(ptr, "-")==0 )
		{
			// 스택이 비어있을 경우 그냥 담는다.
			if(IsEmpty() == 0)
			{
				Push(ptr);
			}
			// 스택에 값이 있을 경우
			else 
			{
				// 어떤 연산자가 들어있던 전부 꺼내어 배열에 보관하고, 
				// 자기 자신을 스택에 넣는다.
				while(1)
				{
					// 스택이 비어있는 경우 자기 자신을 넣는다.
					if(IsEmpty() == 0)
					{
						Push(ptr);
						break;
					}
 
					pchTempOperation = Pop();
					chPostfixBuf[nPostfixBufSIze] = pchTempOperation;
					nPostfixBufSIze++;
				}
			}
		}
		// 숫자인 경우 바로 배열에 담는다.
		else
		{
			//strcpy(chPostfixBuf[nPostfixBufSIze],pchTempOperation); 
			chPostfixBuf[nPostfixBufSIze] = ptr;
			nPostfixBufSIze++;
		}
 
		ptr = strtok(NULL, " ");      // 다음 문자열을 잘라서 포인터를 반환	
	}
 
	//-----------------------------------------------------------------
 
	//-----------------------------------------------------------------
	// 스택 사용이 끝났으므로, 스택에 할당한 메모리 해제
	// 및 사용한 변수들의 메모리 해제
	DisposeStack();
 
	//-----------------------------------------------------------------
 
	// step 1 끝
	// =================================================================
 
 
 
	// =================================================================
	// step 2. 후위 표기법으로 변환된 수식을 스택에 담아 연산.
 
 
	// 연산을 위해 스택을 한번 더 사용합니다. 
	// 이번엔 연산자의 개수만큼 담기는 것이 아닌
	// 숫자의 개수 + 연산자의 개수 만큼 담겨야 합니다.
	//-------------------------------------------------------
	// 스택 초기화(동적)
	// 마지막 계산을 위한 스택의 크기는 (연산자의 개수*2) +1 로 초기화 합니다.
	// 이 곳에는 모든 숫자와 연산자가 다 담깁니다..
	// 예를 들어 1+2+3+4+5 라는 값이 들어오면 9의 크기로 선언해야 합니다.
	// 연산자 = 4개, 숫자 = 5개 이므로 
	// (4*2)+1 총 9개의 스택을 생성
	nFullNum = (nOperationNum * 2) + 1;
	InitStack(nFullNum);
	//-------------------------------------------------------
 
 
	//-------------------------------------------------------
	// 후위 표기법 연산
 
	// 연산을 위해 Pop된 값(숫자)pchTempNum 임시로 담길 변수
	char *pchTempNum = (char *)malloc(MAX_SIZE);
	memset(pchTempNum, 0, MAX_SIZE);
 
	// 계산을 위한 변수들
	int num1, num2, opresult;
 
	// 배열에 들어있는 값을 앞쪽부터 연산합니다.
	for(i =0;i<nPostfixBufSIze;i++)
	{
		// 값이 연산자이면?
 
		// + 연산
		if(strcmp(chPostfixBuf[i], "+")==0)
		{
			// 스택에 보관되어있는 2개의 숫자를 꺼내어 연산합니다.
			pchTempNum = Pop();
			num2 = atoi(pchTempNum);
			pchTempNum = Pop();
			num1 = atoi(pchTempNum);
			opresult = num1 + num2;
 
			// 연산한 값은 다시 넣어줍니다..
			sprintf(pchTempNum,"%d",opresult);
			Push(pchTempNum);
		}
		// - 연산
		else if(strcmp(chPostfixBuf[i], "-")==0)
		{
			// 스택에 보관되어있는 2개의 숫자를 꺼내어 연산합니다..
			pchTempNum = Pop();
			num2 = atoi(pchTempNum);
			pchTempNum = Pop();
			num1 = atoi(pchTempNum);
			opresult = num1 - num2;
 
			// 연산한 값은 다시 넣어줍니다..
			sprintf(pchTempNum,"%d",opresult);
			Push(pchTempNum);
		}
		// * 연산
		else if(strcmp(chPostfixBuf[i], "*")==0)
		{
			// 스택에 보관되어있는 2개의 숫자를 꺼내어 연산합니다..
			pchTempNum = Pop();
			num2 = atoi(pchTempNum);
			pchTempNum = Pop();
			num1 = atoi(pchTempNum);
			opresult = num1 * num2;
 
			// 연산한 값은 다시 넣어줍니다..
			sprintf(pchTempNum,"%d",opresult);
			Push(pchTempNum);
 
		}
		// / 연산
		else if(strcmp(chPostfixBuf[i], "/")==0)
		{
			// 스택에 보관되어있는 2개의 숫자를 꺼내어 연산합니다..
			pchTempNum = Pop();
			num2 = atoi(pchTempNum);
			pchTempNum = Pop();
			num1 = atoi(pchTempNum);
			opresult = num1 / num2;
 
			// 연산한 값은 다시 넣어줍니다..
			sprintf(pchTempNum,"%d",opresult);
			Push(pchTempNum);
		}
		// 숫자의 경우..
		else
		{
			// 스택에 넣는다..
			pchTempNum = chPostfixBuf[i];
			Push(pchTempNum);
		}
	}
 
 
	// 후위 표기법 수식 출력
	printf("후위 표기법 수식 = ");
	for(i=0;i<nFullNum;i++)
	{
 
		printf("%s ",chPostfixBuf[i]);
	}
	printf("\n");
 
	//결과를 출력합니다.
	pchTempNum = Pop();
	printf("result = %s",pchTempNum);
	//-------------------------------------------------------
 
 
	//-----------------------------------------------------------------
	// 스택 사용이 끝났으므로, 스택에 할당한 메모리 해제
	// 및 사용한 변수들의 메모리 해제
	DisposeStack();
	free(pchTempNum);
	free(pchTempOperation);
 
	// 연산까지 전부 잘 되는데 마지막에 이 후위표기법
	// 수식이 담겼던 변수의 메모리를 해제할 때 오류가 발생합니다....ㅜㅜ
	//
	//for (int i = 0; i < nFullNum; i++)
	//{
	//	free(chPostfixBuf[i]);
	//}
	//-----------------------------------------------------------------
 
	// step 2 끝
	// =================================================================
 
	return 0;
}
 
void InitStack(int nSize)
{
	// 스택 메모리 동적 할당
	for (int i = 0; i < nSize; i++)
	{
		g_pchStack[i] =  (char*)malloc(MAX_SIZE);
		memset(g_pchStack[i], 0, MAX_SIZE);
	}
 
	// 스택의 크기
	g_nSize = nSize;
 
	// 스택 초기화시 top을 -1로 설정
	g_nTop = -1; 
}
 
int IsFull()
{
	// Top이 스택의 크기보다 크면 꽉 찬 상태
	if (g_nTop >= g_nSize - 1 )
	{
		// 스택이 꽉 찬 경우
		return 0;
	}
 
	return -1;
}
 
int IsEmpty()
{
	// Top이 -1이면 빈 상태
	if (g_nTop == -1)
	{
		// 스택이 비어있는 경우
		return 0;
	}
 
	return -1;
}
 
void Push(char *chdata)
{
	if (IsFull() == 0)
	{
		printf("Stack Overflow!!! \n");
		return;
	}
 
	// Top을 1 증가
	g_nTop++; 
 
	// 데이터를 char* 형 배열에 보관
	strcpy(g_pchStack[g_nTop], chdata);
}
 
char *Pop()
{
	char *chTemp = (char *)malloc(MAX_SIZE);
 
	// 스택이 비었을 경우
	if (IsEmpty() == 0)
	{
	printf("Stack is empty!!! \n");
	return 0 ;
	}
 
	// chTemp 변수의 스택의 값을 할당합니다.
	strcpy(chTemp, (g_pchStack[g_nTop]));
 
	// Top을 1 감소
	g_nTop--;
 
	return chTemp;
}
 
void DisposeStack()
{
	// 스택에 할당한 메모리 해제
	for (int i = 0; i < g_nSize; i++)
	{
		free(g_pchStack[i]);
	}
}