c언어 자료구조 숙제~! 1부

정말 긴연산... 다들 비슷한거 내서 한개는 특별하게

 

후위연산 + 토큰 +기본 옵션 까지 ~! 주석달기...

 

쫌길다.. 25페이지... ㅋㅋ

 

 

// 사칙연산

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define BOOL int

#define TRUE 1

#define FALSE 0

#define STACKSIZE 20 // 입력할 문자를 20개 까지 받는다

#define BUFFER 256

// 아스키 코드를 사용해서 사칙연산 및 괄호를 입력 받는다

#define ASCII_ADD 43 // + 를 지정

#define ASCII_SUB 45 // - 를 지정

#define ASCII_MUL 42 // * 를 지정

#define ASCII_DIV 47 // / 를 지정

#define ASCII_MOD 37 // % 를 지정

#define ASCII_BRACKET_START 40 // ( 를 지정

#define ASCII_BRACKET_STOP 41 // ) 를 지정

// push, pop, del을 지정 한다

#define FLAG_NONE 0

#define FLAG_PUSH 1

#define FLAG_POP 2

#define FLAG_DEL 3

// 각 리턴을 지정해준다

#define RETURN_NONE 0

#define RETURN_NUM 1

#define RETURN_OPER 2

#define RETURN_START 3

#define RETURN_STOP 4

typedef struct _NODE

{

char nData;

_NODE *pPrev;

_NODE *pNext;

} NODE, *PNODE;

typedef struct _LINKEDLIST

{

NODE *pTop;

NODE *pBottom;

int nSize;

} LINKEDLIST, *PLINKEDLIST;

// 함수의 원형을 나열한다

PLINKEDLIST Create();

BOOL Input(PLINKEDLIST pLinkedList, char *szInfix, char* szPostfix);

BOOL PushLinkedList(PLINKEDLIST pLinkedList, char *cOperator);

char PopLinkedList(PLINKEDLIST pLinkedList);

BOOL PrintLinkedList(char *pToken, char *pValue, PLINKEDLIST pLinkedList, char *szResult, int nFlag);

int Process(char *szPostfix);

BOOL PushArray(int *pStack, int nValue, int *nTop);

int PopArray(int *pStack, int *nTop);

BOOL PrintArray(int *pStack, char *pToken, int nValue, int nTop, int nFlag);

char* AddResult(char *pResult, char *pToken, int nSize);

char* NextTokenIn(char *pCurrent, char *pToken, int *nFlag);

char* NextTokenPost(char *pCurrent, char *pToken, int *nFlag);

BOOL ParseInfix(char *pCurrent);

BOOL GetKey(char *szTemp);

// 프로그램 시작점

int main()

{

PLINKEDLIST pLL;

char szInfix[BUFFER];

char szPostfix[BUFFER];

int nResult;

// 행렬리스트 링크드 리스트를 생성한다

pLL = Create();

// 화면 출력

printf("===============================================================================\n");

printf(" 스택 구현 프로그램\n");

printf("===============================================================================\n\n");

// 수식 입력 함수 호출

Input(pLL, szInfix, szPostfix);

printf("===============================================================================\n");

printf(" 후위 계산 과정 출력\n");

printf("===============================================================================\n\n");

// 수식 계산 함수 호출

nResult = Process(szPostfix);

printf("===============================================================================\n");

printf(" 결과값 출력\n");

printf("===============================================================================\n\n");

// 결과 출력

printf("INFIX : %s\n", szInfix);

printf("POSTFIX : %s\n", szPostfix);

printf("RESULT : %d\n", nResult);

printf("\n===============================================================================");

// 링크드리스트 헤더노드 메모리 소거

free(pLL);

getchar();

return 0;

}

// 새로운 링크리스트를 만드는 부분

PLINKEDLIST Create()

{

// 노드의 시작을 가리키는 포인터를 생성한다

PLINKEDLIST pLinkedList;

// 말록 함수를 이용해서 LINKEDLIST의 사이즈만큼 pLinkedList로 삽입한다

pLinkedList = (PLINKEDLIST)malloc(sizeof(LINKEDLIST));

// 노드의 TOP, BOTTOM을 NULL(공백)로 지정한다

pLinkedList->pTop = NULL;

pLinkedList->pBottom = NULL;

//스택의 크기를 0으로 초기화 한다

pLinkedList->nSize = 0;

return pLinkedList;

}

//값을 삽입 해주는 부분

BOOL Input(PLINKEDLIST pLinkedList, char *szInfix, char* szPostfix)

{

char szTemp[BUFFER];

char szResult[BUFFER];

char szToken[BUFFER];

char *pCurrent;

char *pResult;

char cTemp;

int nFlag;

if(pLinkedList == NULL) //pLinkedList가 공백이면

{

// 초기화 되지 않았다고 알림이 나온뒤

printf("Input(): LinkedList가 초기화 될수없다\n");

// 리턴해준다

return FALSE;

}

//배열을 NULL로 초기화 한다(다른것과 겹쳐서 오류가 나지않기위해서)

//memset=포인터가 가리키는 주소에서부터 바이트수만큼의 길이를 값으로 초기화 시킨다

memset(szResult, '\0', sizeof(szResult));

printf("[?] 수식을 입력. ");

printf("예) 1+2*(3+4)/5%6+(7*8)\n");

while(TRUE)

{

printf(">> ");

// 값 입력

GetKey(szTemp);

// 입력된 수식이 올바른 형식인지 원하는 모양인지 확인한다(파싱)

if(ParseInfix(szTemp) == TRUE)

{

break;

}

else

{

printf("[!] 잘못된 수식이 입력\n");

}

}

// 순환을 돌 토큰 지정 하는 부분

pCurrent = szTemp;

pResult = szResult;

// 중위입력값 보관하는 부분

strcpy(szInfix, szTemp);

while(*pCurrent != NULL)// 널이 아닐경우

{

memset(szToken, '\0', sizeof(szToken));

// Infix형 수식의 토큰을 나눈다

pCurrent = NextTokenIn(pCurrent, szToken, &nFlag);

if(nFlag == RETURN_NONE)

{

continue;

}

// 숫자일때

else if(nFlag == RETURN_NUM)

{

pResult = AddResult(pResult, szToken, strlen(szToken));

PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_NONE);

}

else if(nFlag == RETURN_OPER)

{

if(szToken[0] == ASCII_ADD || szToken[0] == ASCII_SUB)

{

// 스택의 최상위가 NULL이 아닐때

if(pLinkedList->pTop != NULL)

{

while(TRUE)

{

// 스택이 비어있을때 멈춘다

if(pLinkedList->pTop == NULL)

{

break;

}

// 스택위 최상위에 같은 우선순위 (*, /, %, +, -) 연산자가 있을경우 스택에서 꺼내주는 부분

if(pLinkedList->pTop->nData == ASCII_MUL || pLinkedList->pTop->nData == ASCII_DIV || pLinkedList->pTop->nData == ASCII_MOD

|| pLinkedList->pTop->nData == ASCII_ADD || pLinkedList->pTop->nData == ASCII_SUB)

{

// 스택 POP

cTemp = PopLinkedList(pLinkedList);

pResult = AddResult(pResult, &cTemp, 1);

PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);

}

else

{

break;

}

}

}

PushLinkedList(pLinkedList, szToken);

PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);

}

else if(szToken[0] == ASCII_MUL || szToken[0] == ASCII_DIV || szToken[0] == ASCII_MOD)

{

// 스택의 최상위가 NULL이 아닐때

if(pLinkedList->pTop != NULL)

{

while(TRUE)

{

// 스택이 비어있을때

if(pLinkedList->pTop == NULL)

{

break;

}

// 스택의 최상위에 같은 우선순위의 (*, /, %) 연산자가 있을경우 스택에서 꺼낸다

if(pLinkedList->pTop->nData == ASCII_MUL || pLinkedList->pTop->nData == ASCII_DIV || pLinkedList->pTop->nData == ASCII_MOD)

{

// 스택 POP

cTemp = PopLinkedList(pLinkedList);

pResult = AddResult(pResult, &cTemp, 1);

PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);

}

else

{

break;

}

}

}

// 스택에 넣는다

PushLinkedList(pLinkedList, szToken);

PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);

}

}

// 괄호 시작일때

else if(nFlag == RETURN_START)

{

// 스택에 넣는다

PushLinkedList(pLinkedList, szToken);

PrintLinkedList(szToken, szToken, pLinkedList, szResult, FLAG_PUSH);

}

// 괄호가 닫힐때

else if(nFlag == RETURN_STOP)

{

// TOP이 NULL이 아니면서 열린 괄호가 나올때까지 스택의 값들을 꺼낸다

while(pLinkedList->pTop != NULL && pLinkedList->pTop->nData != ASCII_BRACKET_START)

{

// 스택 POP

cTemp = PopLinkedList(pLinkedList);

pResult = AddResult(pResult, &cTemp, 1);

PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);

}

// 열린괄호를 삭제한다

cTemp = PopLinkedList(pLinkedList);

PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_DEL);

}

// 그 이외의 값이 입력되었을때

else

{

// 잘못된 값이라 출력하고 리턴해준다

printf("[!] 잘못된 값이 입력되었다");

return FALSE;

}

}

// 모든 토큰을 돌았을때

strcpy(szToken, "end");

// 스택안에 들어있는 데이터를 모두 꺼낸다

while(pLinkedList->nSize > 0)

{

// 스택 POP

cTemp = PopLinkedList(pLinkedList);

pResult = AddResult(pResult, &cTemp, 1);

PrintLinkedList(szToken, &cTemp, pLinkedList, szResult, FLAG_POP);

}

// 후위 변환 완료후 결과값 복사

strcpy(szPostfix, szResult);

return TRUE;

}

// Push LinkedList Stack 부분

BOOL PushLinkedList(PLINKEDLIST pLinkedList, char *cOperator)

{

PNODE pNewNode;

// 스택이 풀인지 체크 한다

if(pLinkedList->nSize == STACKSIZE)

{

printf("[!] 링크드리스트 스택이 가득차 있다");

return FALSE;

}

// 링크드 리스트가 정상적으로 생성되있지 않을경우

if(pLinkedList == NULL)

{

printf("PushLinkedList(): LinkedList가 초기화 될수없다\n");

return FALSE;

}

// 포인터 구조체에 값을 입력하기 위해 메모리 영역을 할당한다

pNewNode = (PNODE)malloc(sizeof(NODE));

// 위의 과정을 거쳐 메모리에 영역을 할당하는데 실패하였을 경우

if(pNewNode == NULL)

{

printf("PushLinkedList(): LinkedList 노드를 생성 할 수가없다\n");

return FALSE;

}

// 입력된 연산자를 스택에 입력한다

pNewNode->nData = (char)*cOperator;

// 이전 노드의 포인터를 NULL로 한다

pNewNode->pPrev = NULL;

// 처음으로 입력되는 스택일경우

if(pLinkedList->pTop == NULL)

{

pNewNode->pNext = NULL;

pLinkedList->pTop = pNewNode;

pLinkedList->pBottom = pNewNode;

}

// 두번째 이상으로 입력되는 스택일경우

else

{

pLinkedList->pTop->pPrev = pNewNode;

pNewNode->pNext = pLinkedList->pTop;

pLinkedList->pTop = pNewNode;

}

// 스택의 사이즈를 하나더 증가시킨다

pLinkedList->nSize++;

return TRUE;

}

// Pop LinkedList Stack 부분

char PopLinkedList(PLINKEDLIST pLinkedList)

{

char cTemp;

PNODE pCurrent;

// 스택이 비어있는지 검사한다

if(pLinkedList->nSize == 0)

{

printf("[!] 링크드리스트 스택이 비어 있다");

return FALSE;

}

// 링크드 리스트가 정상적으로 생성되어있지 않을경우

if(pLinkedList == NULL)

{

printf("PopLinkedList(): LinkedList가 초기화 될수 없다\n");

return FALSE;

}

// 메모리에서 삭제하기 위한 링크를 남겨둔다

pCurrent = pLinkedList->pTop;

// 링크드 리스트 스택 사이즈를 1줄인다

pLinkedList->nSize--;

// 스택이 비었을때

if(pLinkedList->nSize == 0)

{

pLinkedList->pTop = NULL;

pLinkedList->pBottom = NULL;

}

// 스택이 비어있지 않을때 Top을 조정한다

else

{

pLinkedList->pTop = pLinkedList->pTop->pNext;

pLinkedList->pTop->pPrev = NULL;

}

// 삭제될 최상의 스택의 값을 받는다.

cTemp = pCurrent->nData;

// 메모리 소거

free(pCurrent);

// 값 리턴

return cTemp;

}

// Print LinkedList Stack부분

BOOL PrintLinkedList(char *pToken, char *pValue, PLINKEDLIST pLinkedList, char *szResult, int nFlag)

{

PNODE pCurrent;

char *pResult;

char szTemp[BUFFER];

int nReturn;

//pLinkedList가 공백일때

if(pLinkedList == NULL)

{

printf("PrintLinkedList(): LinkedList가 초기화 될수없다\n");

return FALSE;

}

// 현재 토큰 값 출력

printf("TOKEN : %s\n", pToken);

// 플래그 출력, PUSH인지 POP인지 DELETE인지 구별한다

switch(nFlag)

{

case FLAG_NONE :

// 스택을 거치지 않을때

printf("COPY(-)\n");

break;

case FLAG_PUSH :

// PUSH일때

printf("PUSH(%s)\n", pToken);

break;

case FLAG_POP :

// POP일때

printf("POP(%c)\n", pValue[0]);

break;

case FLAG_DEL :

// DELETE일때

printf("DELETE(%c)\n", pValue[0]);

break;

}

// 스택안에 들어있는 값 출력

printf("STACK : ");

pCurrent = pLinkedList->pBottom;

while(pCurrent != NULL)

{

// 링크드 리스트를 돌며 값을 출력한다

printf("%c ", pCurrent->nData);

pCurrent = pCurrent->pPrev;

}

// 결과 출력

printf("\nOUTPUT : ");

pResult = szResult;

// 토큰을 돌며 출력한다

while(*pResult != '\0')

{

memset(szTemp, '\0', sizeof(szTemp));

// 토큰을 돌며 출력한다

pResult = NextTokenPost(pResult, szTemp, &nReturn);

// 숫자나 연산자만 출력한다

if(nReturn == RETURN_NUM || nReturn == RETURN_OPER)

{

printf("%s ", szTemp);

}

}

getchar();

printf("\n");

return TRUE;

}

int Process(char *szPostfix)

{

char *pCurrent;

char szTemp[BUFFER];

int aStack[STACKSIZE];

int nReturn;

int nTop;

int nTemp[2];

// 스택의 탑위치를 가리키는 nTop초기화(0부터 시작하므로-1으로 초기화)

nTop = -1;

// 후위변경된 수식의 시작을 포인터 지정

pCurrent = szPostfix;

// 토큰을 돌며 출력한다

while(*pCurrent != '\0')

{

memset(szTemp, '\0', sizeof(szTemp));

// 토큰을 돌며 출력한다

pCurrent = NextTokenPost(pCurrent, szTemp, &nReturn);

// 숫자는 무조건 push한다

if(nReturn == RETURN_NUM)

{

PushArray(aStack, atoi(szTemp), &nTop);

PrintArray(aStack, szTemp, atoi(szTemp), nTop, FLAG_PUSH);

}

// 연산자가 나오면 이전의 스택 값 두개를 연산하여 결과를 다시 push한다

else if(nReturn == RETURN_OPER)

{

nTemp[1] = PopArray(aStack, &nTop);

PrintArray(aStack, szTemp, nTemp[1], nTop, FLAG_POP);

nTemp[0] = PopArray(aStack, &nTop);

PrintArray(aStack, szTemp, nTemp[0], nTop, FLAG_POP);

switch(szTemp[0])

{

case '+' :

// 덧셈 연산자 일때

PushArray(aStack, (int)(nTemp[0] + nTemp[1]), &nTop);

break;

case '-' :

// 뺄셈 연산자 일때

PushArray(aStack, (int)(nTemp[0] - nTemp[1]), &nTop);

break;

case '*' :

// 곱셈 연산자 일때

PushArray(aStack, (int)(nTemp[0] * nTemp[1]), &nTop);

break;

case '/' :

// 나눗셈 연산자 일때

PushArray(aStack, (int)(nTemp[0] / nTemp[1]), &nTop);

break;

case '%' :

// 나머지 연산자 일때

PushArray(aStack, (int)(nTemp[0] % nTemp[1]), &nTop);

break;

}

PrintArray(aStack, szTemp, aStack[nTop], nTop, FLAG_PUSH);

}

}

// 최종 결과 값 리턴

return aStack[0];

}

// Push Stack

BOOL PushArray(int *pStack, int nValue, int *nTop)

{

// 스택사이즈만큼 가득차 있을경우

if(*nTop == STACKSIZE)

{

printf("[!] 배열 스택이 가득차 있다\n");

return FALSE;

}

// TOP 위치 상승

(*nTop)++;

// 푸쉬할 값 입력

*(pStack + *nTop) = nValue;

return TRUE;

}

// Pop Stack

int PopArray(int *pStack, int *nTop)

{

int nTemp;

// 스택이 비어있을 경우

if(*nTop == -1)

{

printf("[!] 배열 스택이 비어 있다\n");

return FALSE;

}

// 팝을 하기 위한 값 복사

nTemp = *(pStack + *nTop);

// TOP위치 감소

(*nTop)--;

return nTemp;

}

// Print Stack

BOOL PrintArray(int *pStack, char *pToken, int nValue, int nTop, int nFlag)

{

int nCount;

printf("TOKEN : %s\n", pToken); //pToken 값을 출력

if(nFlag == FLAG_PUSH)//FLAG_PUSH와 같으면

{

printf("PUSH(%d)\n", nValue);//nValue(push) 값을 출력

}

else if(nFlag == FLAG_POP)//또는 FLAG_POP와 같을때

{

printf("POP(%d)\n", nValue);//nValue(pop)를 출력

}

printf("STACK : ");

for(nCount = 0 ; nCount <= nTop ; nCount++)//nCount를 nTop보다 같으나 클때까지 출력

{

printf("%d ", *(pStack + nCount));

}

// 사용자가 엔터를 입력할때까지 기다린다

getchar();

printf("\n");

return TRUE;

}

// Add Character Array

char* AddResult(char *pResult, char *pToken, int nSize)

{

int nCount;

// 토큰을 결과 배열에 입력한다

for(nCount = 0; nCount < nSize ; nCount++)

{

*pResult = *pToken;

// 결과 배열 포인터를 증가시킨다

pResult++;

pToken++;

}

// 널문자 삽입

*pResult = '\0';

return pResult;

}

// Next Token Pointer

char* NextTokenIn(char *pCurrent, char *pToken, int *nFlag)

{

// 숫자인지 오퍼레이터인지 검사하는 플래그 초기화

*nFlag = 0;

// 숫자일때

if(*pCurrent < 58 && *pCurrent > 47)

{

// 이전 토큰의 값이 -이면서 그 이전토큰의 값이 숫자가 아닐때

if(*(pCurrent - 1) == ASCII_SUB && (*(pCurrent - 2) > 57 || *(pCurrent - 2) < 48))

{

*pToken = ASCII_SUB;

pToken++;

}

else

{

*pToken = ASCII_ADD;

pToken++;

}

// 이어 나오는 토큰이 숫자일경우 계속 출력한다

while(*pCurrent < 58 && *pCurrent > 47)

{

*pToken = *pCurrent;

pToken++;

pCurrent++;

}

// 숫자일경우

*nFlag = RETURN_NUM;

}

else if(*pCurrent == ASCII_BRACKET_START || *pCurrent == ASCII_BRACKET_STOP)

{

if(*pCurrent == ASCII_BRACKET_START)

{

*nFlag = RETURN_START;

}

else

{

*nFlag = RETURN_STOP;

}

*pToken = *pCurrent;

pToken++;

pCurrent++;

}

else

{

// 앞의 토큰이 숫자일 경우

if(*(pCurrent - 1) < 58 && *(pCurrent - 1) > 47 || *(pCurrent - 1) == ASCII_BRACKET_STOP)

{

*pToken = *pCurrent;

pToken++;

// 연산식일 경우

*nFlag = RETURN_OPER;

}

pCurrent++;

}

return pCurrent;

}

// Next Token Pointer

char* NextTokenPost(char *pCurrent, char *pToken, int *nFlag)

{

// 숫자인지 오퍼레이터인지 검사하는 플래그 초기화

*nFlag = RETURN_NONE;

// 숫자일때

if(*pCurrent < 58 && *pCurrent > 47)

{

// 이전 토큰의 값이 -일때

if(*(pCurrent - 1) == ASCII_SUB)

{

*pToken = ASCII_SUB;

pToken++;

}

// 이어 나오는 토큰이 숫자일경우 계속 출력한다

while(*pCurrent < 58 && *pCurrent > 47)

{

*pToken = *pCurrent;

pToken++;

pCurrent++;

}

// 숫자일경우

*nFlag = RETURN_NUM;

}

// 연산식일때

else

{

// 뒤의 토큰이 숫자일 경우

if(*(pCurrent + 1) > 57 || *(pCurrent + 1) < 48)

{

*pToken = *pCurrent;

pToken++;

*nFlag = RETURN_OPER;

}

pCurrent++;

}

return pCurrent;

}

// Get Key 키입력 처리

BOOL GetKey(char *szTemp)

{

int nCount;

// fgets로 값을 입력받는다. BUFFER이상 길이의 값이 입력될 경우 짤린다

fgets(szTemp, BUFFER, stdin);

// 반복문, 값이 입력되지 않은 부분에 널문자를 채운다

for(nCount = 0 ; nCount < BUFFER ; nCount++)

{

if(szTemp[nCount] < 0 || szTemp[nCount] == '\n')

{

// 아스키코드 0번 이하이거나 엔터문자일경우 널문자로 교체

szTemp[nCount] = '\0';

}

}

return TRUE;

}

// Parserinfix

BOOL ParseInfix(char *pCurrent)

{

int nCountNum;

int nCountOper;

int nCountBracket_Start;

int nCountBracket_Stop;

// 각각의 정보를 기록하는 카운터를 초기화 한다

nCountNum = 0;

nCountOper = 0;

nCountBracket_Start = 0;

nCountBracket_Stop = 0;

while(*pCurrent != '\0')

{

// 현재 토큰이 숫자일때

if(*pCurrent < 58 && *pCurrent > 47)

{

// 이전 토큰이 숫자가 아닐때

if(*(pCurrent - 1) > 57 || *(pCurrent - 1) < 48)

{

nCountNum++;

}

}

// 현재 토큰이 연산자일때

else

{

// 여는 괄호일때, 이전 토큰이 숫자이면 안된다

if(*pCurrent == ASCII_BRACKET_START && (*(pCurrent - 1) > 57 || *(pCurrent - 1) < 48))

{

// 닫는 괄호가 여는 괄호보다 많을수 없음

nCountBracket_Start++;

}

// 닫는 괄호일때

else if(*pCurrent == ASCII_BRACKET_STOP)

{

if(nCountBracket_Stop > nCountBracket_Start)

{

return FALSE;

}

nCountBracket_Stop++;

}

// 연산자 일때

else if(*pCurrent == ASCII_ADD || *pCurrent == ASCII_SUB || *pCurrent == ASCII_MUL || *pCurrent == ASCII_DIV || *pCurrent == ASCII_MOD)

{

// 이전 토큰이 숫자일때 연산자임

if(*(pCurrent - 1) < 58 && *(pCurrent - 1) > 47 || *(pCurrent - 1) == ASCII_BRACKET_STOP)

{

nCountOper++;

}

// 이전 토큰이 시작하는 괄호일때

else if(*(pCurrent - 1) == ASCII_BRACKET_START)

{

// 현재 토큰이 *, /, %이라면 잘못된 수식

if(*pCurrent == ASCII_MUL || *pCurrent == ASCII_DIV || *pCurrent == ASCII_MOD)

{

return FALSE;

}

}

}

else

{

// 위에 있지 않는 문자가 입력되었을 경우

return FALSE;

}

}

pCurrent++;

}

// 여는 괄호와 닫는 괄호의 수가 다를 경우 잘못된 형식

if(nCountBracket_Start != nCountBracket_Stop)

{

return FALSE;

}

// 숫자와 연산자+1의 수가 다를 경우 잘못된 형식

if(nCountNum != (nCountOper + 1))

{

return FALSE;

}

return TRUE;

}