1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 #include <malloc.h> 6 7 #define STACK_SIZE 100 8 #define APPEND_SIZE 10 9 10 struct SNode{ 11 float data; /*存放操作数或者计算结果*/ 12 char ch; /*存放运算符*/ 13 }; 14 15 struct Stack{ 16 SNode *top; 17 SNode *base; 18 int size; 19 }; 20 21 /*栈操作函数*/ 22 int InitStack(Stack &S); /*创建栈*/ 23 int DestroyStack(Stack &S); /*销毁栈*/ 24 int ClearStack(Stack &S); /*清空栈*/ 25 int GetTop(Stack S, SNode &e); /*取出栈顶结点并返回节点值*/ 26 int Push(Stack &S,SNode e); /*将结点e压入栈*/ 27 int Pop(Stack &S,SNode &e); /*删除栈顶结点并返回其节点值*/ 28 29 /*表达式计算器相关函数*/ 30 char get_precede(char s,char c); /*判断运算符s和c的优先级*/ 31 int isOpr(char c); /*判断输入的字符是不是运算符,是则返回0,否返回1*/ 32 float operate(float x, char opr, float y); /*计算x和y经过运算符opr计算后的结果*/ 33 float compute(); /*表达式结算器主函数*/ 34 char *killzero(float result); /*去掉结果后面的0*/ 35 36 int InitStack(Stack &S) 37 { 38 S.base=(SNode *)malloc(STACK_SIZE * sizeof(struct SNode)); 39 if(S.base==NULL) 40 { 41 printf("动态分配内存失败!"); 42 return -1; 43 } 44 S.top=S.base; 45 S.size=STACK_SIZE; 46 return 0; 47 } 48 49 int DestroyStack(Stack &S) 50 { 51 free(S.base); 52 return 0; 53 } 54 55 int ClearStack(Stack &S) 56 { 57 S.top=S.base; 58 return 0; 59 } 60 61 int GetTop(Stack S,SNode &e) 62 { 63 if(S.top==S.base) 64 { 65 printf("栈以为空!"); 66 return -1; 67 } 68 e=*(S.top-1); 69 return 0; 70 } 71 72 int Push(Stack &S,SNode e) 73 { 74 if(S.top-S.base>=S.size) 75 { 76 S.base=(SNode *)realloc(S.base,(S.size+APPEND_SIZE)*sizeof(struct SNode)); 77 if(S.base==NULL) 78 { 79 printf("动态分配内存失败!"); 80 return -1; 81 } 82 S.top=S.base+S.size; 83 S.size+=APPEND_SIZE; 84 } 85 *S.top=e; 86 S.top++; 87 return 0; 88 } 89 90 int Pop(Stack &S,SNode &e) 91 { 92 if(S.top==S.base) 93 { 94 printf("栈为空!"); 95 return -1; 96 } 97 e=*(S.top-1); 98 S.top--; 99 return 0; 100 } 101 102 char get_precede(char s,char c) 103 { 104 switch(s) 105 { 106 case '+': 107 case '-': 108 if(c=='+'||c=='-') 109 return '>'; 110 else if(c=='*'||c=='/') 111 return '<'; 112 else if(c=='(') 113 return '<'; 114 else if(c==')') 115 return '>'; 116 else 117 return '>'; 118 case '*': 119 case '/': 120 if(c=='+'||c=='-') 121 return '>'; 122 else if(c=='*'||c=='/') 123 return '>'; 124 else if(c=='(') 125 return '<'; 126 else if(c==')') 127 return '>'; 128 else 129 return '>'; 130 case '(': 131 if(c=='+'||c=='-') 132 return '<'; 133 else if(c=='*'||c=='/') 134 return '<'; 135 else if(c=='(') 136 return '<'; 137 else if(c==')') 138 return '='; 139 else 140 return 'E'; 141 case ')': 142 if(c=='+'||c=='-') 143 return '>'; 144 else if(c=='*'||c=='/') 145 return '>'; 146 else if(c=='(') 147 return 'E'; 148 else if(c==')') 149 return '>'; 150 else 151 return '>'; 152 case '#': 153 if(c=='+'||c=='-') 154 return '<'; 155 else if(c=='*'||c=='/') 156 return '<'; 157 else if(c=='(') 158 return '<'; 159 else if(c==')') 160 return 'E'; 161 else 162 return '='; 163 default: 164 break; 165 } 166 return 0; 167 } 168 169 int isOpr(char c) 170 { 171 if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='=') 172 return 0; 173 else 174 return 1; 175 } 176 177 float operate(float x, char opr, float y) 178 { 179 float result; 180 switch (opr) 181 { 182 case '+': 183 result = x + y; 184 break; 185 case '-': 186 result = x - y; 187 break; 188 case '*': 189 result = x * y; 190 break; 191 case '/': 192 if (y == 0) 193 { 194 printf("Divided by zero!\n"); 195 return 0; 196 } 197 else 198 { 199 result = x / y; 200 break; 201 } 202 default: 203 printf("Bad Input.\n"); 204 return 0; 205 } 206 return result; 207 } 208 209 float compute() /*计算的时候运算符栈顶结点的优先级始终最低*/ 210 { 211 Stack optr,opnd; 212 struct SNode opr_in,opn_in,opr_top,opn_tmp,e,a,b,opr_t; 213 char c; 214 char buf[16]; 215 int i=0; 216 217 InitStack(optr); /*用于寄存运算符*/ 218 InitStack(opnd); /*用于寄存操作数和计算结果*/ 219 memset(buf,0,sizeof(buf)); 220 221 printf("Enter your expression:"); 222 223 opr_in.ch='#'; 224 Push(optr,opr_in); /*'#'入栈*/ 225 GetTop(optr,opr_top); 226 c=getchar(); 227 while(c!='='||opr_top.ch!='#') 228 { 229 if(isOpr(c)!=0) /*不是运算符则保存到buf中,以便得到操作数*/ 230 { 231 buf[i]=c; 232 i++; 233 c=getchar(); 234 } 235 else /*是运算符*/ 236 { 237 buf[i]='\0'; 238 if(i) /*判断buf是否为空,不为空则取出值,压入操作数寄存器,并将buf置为空*/ 239 { 240 opn_in.data=(float)atof(buf); 241 Push(opnd,opn_in); 242 printf("opnd入栈:[%f]\n",opn_in.data); 243 i=0; 244 memset(buf,0,sizeof(buf)); 245 } 246 opr_in.ch=c; 247 switch(get_precede(opr_top.ch,c)) /*根据运算符优先级做相应操作*/ 248 { 249 case '<': /*优先级小于栈顶结点,则运算符入栈*/ 250 Push(optr,opr_in); 251 printf("optr入栈:[%c]\n",opr_in.ch); 252 c=getchar(); 253 break; 254 case '=': /*优先级等于栈顶结点,即是括号,去掉括号*/ 255 Pop(optr,e); 256 printf("optr出栈:去掉括号\n"); 257 c=getchar(); 258 break; 259 case '>': /*优先级大于栈顶结点,取操作数和运算符计算*/ 260 Pop(optr,opr_t); 261 printf("optr出栈:[%c]\n",opr_t.ch); 262 if(Pop(opnd,b)<0) 263 { 264 printf("Bad Input!\n"); 265 fflush(stdin); 266 return -1; 267 } 268 printf("opnd出栈:[%f]\n",b.data); 269 if(Pop(opnd,a)<0) 270 { 271 printf("Bad Input!\n"); 272 fflush(stdin); 273 return -1; 274 } 275 printf("opnd出栈:[%f]\n",a.data); 276 opn_tmp.data=operate(a.data,opr_t.ch,b.data); /*计算*/ 277 Push(opnd,opn_tmp); /*将计算结果压入操作数寄存器*/ 278 printf("结果入栈:[%f]\n",opn_tmp.data); 279 break; 280 } 281 } 282 GetTop(optr,opr_top); /*取出运算符寄存器栈顶结点*/ 283 } 284 GetTop(opnd,opn_tmp); 285 DestroyStack(optr); 286 DestroyStack(opnd); 287 return opn_tmp.data; 288 } 289 290 char *killzero(char *res,float result) 291 { 292 int i; 293 294 sprintf(res,"%f",result); 295 i=(int)strlen(res)-1; 296 while(i&&res[i]=='0') 297 { 298 res[i]='\0'; 299 i--; 300 } 301 if(res[i]=='.') 302 res[i]='\0'; 303 return res; 304 } 305 306 int main() 307 { 308 char ch; 309 char res[64]; 310 float result; 311 while(1) 312 { 313 result=compute(); 314 printf("\nThe result is:%s\n",killzero(res,result)); 315 printf("Do you want to continue(y/n)?:") ; 316 getchar(); 317 scanf("%c",&ch); 318 putchar(ch); 319 if(ch=='n'||ch=='N') 320 break; 321 else 322 system("cls"); 323 } 324 return 0; 325 }