注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

熊猫正正的博客

熊猫正正的天空

 
 
 

日志

 
 

C语言简易计算器(中缀表达式转后缀表达式,通过堆栈实现)  

2015-05-11 12:22:45|  分类: C/C++ |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

用C语言,写了一个简易的计算器,只有加减乘除,没有括号,但是若果要实现括号也是很容易的。

其核心思想是将输入的中缀表达式转换为后缀表达式,转换的思想主要参考了这位大牛的博客:http://blog.csdn.net/ssjhust123/article/details/8001651

例如:输入中缀表达式2+2*3/2-1,程序可将其转换成后缀表达式2,2,3,2,/,*,+,1,-  其中','是为了间隔开数字,便于提取。最终的输出结果为:4

第一次发帖,本人菜鸟,欢迎高手批评指正!

代码如下:

  1. #include "stdio.h"  
  2. #include "string.h"  
  3. #include "malloc.h"  
  4.   
  5. typedef struct tag_STACK_STRU  
  6. {  
  7.     float valueData;  
  8.     struct tag_STACK_STRU *pNext;  
  9. }stackList;                 //用链表实现数据的存储  
  10.   
  11. stackList *g_stOperand = NULL;          //操作数  
  12. stackList *g_stOperator = NULL;                 //操作符  
  13.   
  14. void makeEmpty(stackList *stack);           //清空栈  
  15. char isEmpty(stackList *stack);         //判断栈是否为空  
  16.   
  17. void push(stackList *stack, float data);        //入栈操作  
  18. void pop(stackList *stack);             //出栈操作  
  19. void calculate(char *p);                //计算的子程序      
  20. void changeStr(char *p);                //将中缀表达式转换为后缀表达式  
  21.   
  22. char suffixStr[1024];  
  23.   
  24. int main()  
  25. {  
  26.     // 业务代码实现处  
  27.   
  28.     char *p = (char *)malloc(sizeof(char));  
  29.   
  30.     g_stOperand = (stackList *)malloc(sizeof(stackList));  
  31.     g_stOperand->pNext = NULL;  
  32.     makeEmpty(g_stOperand);  
  33.   
  34.     g_stOperator = (stackList *)malloc(sizeof(stackList));  
  35.     g_stOperator->pNext = NULL;  
  36.     makeEmpty(g_stOperator);  
  37.   
  38.     scanf("%s",p);      //获取输入的中缀表达式  
  39.   
  40.     changeStr(p);       //将中缀表达式转换成后缀表达式  
  41.     calculate(suffixStr);   //通过后缀表达式进行计算  
  42.   
  43.     printf("%d", (int)g_stOperand->pNext->valueData); //打印出最后结果  
  44.       
  45.     //while(1);  
  46.     return 0;  
  47. }  
  48.   
  49. //清空栈的操作  
  50. void makeEmpty(stackList *stack)  
  51. {  
  52.     if (stack == NULL)  
  53.         printf("must creat stack first");  
  54.       
  55.     while(!isEmpty(stack))  
  56.         pop(stack);   
  57. }  
  58. //判断栈是否为空  
  59. char isEmpty(stackList *stack)  
  60. {  
  61.     return (stack->pNext == NULL);  
  62. }  
  63. //入栈操作  
  64. void push(stackList *stack, float data)  
  65. {  
  66.     stackList *pTemp = (stackList *)malloc(sizeof(stackList));  
  67.     if (stack == g_stOperand)   //操作数入栈  
  68.     {  
  69.         if (pTemp == NULL)  
  70.             return;  
  71.         pTemp->valueData = data;  
  72.         pTemp->pNext = stack->pNext;  
  73.         stack->pNext = pTemp;  
  74.     }  
  75.     if (stack == g_stOperator)  //操作符入栈  
  76.     {  
  77.         if (pTemp == NULL)  
  78.             return;  
  79.         pTemp->valueData = data;  
  80.         pTemp->pNext = stack->pNext;  
  81.         stack->pNext = pTemp;  
  82.     }  
  83. }  
  84. //出栈操作  
  85. void pop(stackList *stack)  
  86. {  
  87.     stackList *pTop = NULL;  
  88.     if (isEmpty(stack))  
  89.         return;  
  90.     pTop = stack->pNext;  
  91.     stack->pNext = stack->pNext->pNext;  
  92.     free(pTop);  
  93. }  
  94. //计算  
  95. void calculate(char *p)  
  96. {  
  97.     float a, b, t;  
  98.     char temp[100];  
  99.     int i = 0;  
  100.   
  101.     makeEmpty(g_stOperand);  
  102.     makeEmpty(g_stOperator);  
  103.   
  104.     while(*p)  
  105.     {  
  106.         if((*p >= '0') && (*p <= '9'))  
  107.         {  
  108.   
  109.             while((*p >= '0') && (*p <= '9'))  
  110.             {  
  111.                 temp[i] = *p;  
  112.                 p++;  
  113.                 i++;  
  114.             }  
  115.             push(g_stOperand, atoi(temp));  
  116.             memset(temp, 0, sizeof(temp));  
  117.             i = 0;  
  118.         }  
  119.         if (*p == '+')  
  120.         {  
  121.             a = g_stOperand->pNext->valueData;  
  122.             pop(g_stOperand);  
  123.             b = g_stOperand->pNext->valueData;  
  124.             pop(g_stOperand);  
  125.             t = b + a;   
  126.             push(g_stOperand, t);  
  127.         }  
  128.         if (*p == '-')  
  129.         {  
  130.             a = g_stOperand->pNext->valueData;  
  131.             pop(g_stOperand);  
  132.             b = g_stOperand->pNext->valueData;  
  133.             pop(g_stOperand);  
  134.             t = b - a;  
  135.             push(g_stOperand, t);  
  136.         }  
  137.         if (*p == '*')  
  138.         {  
  139.             a = g_stOperand->pNext->valueData;  
  140.             pop(g_stOperand);  
  141.             b = g_stOperand->pNext->valueData;  
  142.             pop(g_stOperand);  
  143.             t = b * a;  
  144.             push(g_stOperand, t);  
  145.         }  
  146.         if (*p == '/')  
  147.         {  
  148.             a = g_stOperand->pNext->valueData;  
  149.             pop(g_stOperand);  
  150.             b = g_stOperand->pNext->valueData;  
  151.             pop(g_stOperand);  
  152.             t = b / a;  
  153.             push(g_stOperand, t);  
  154.         }  
  155.         p++;  
  156.     }  
  157. }  
  158.   
  159. void changeStr(char *p)  
  160. {  
  161.     stackList *k = (stackList *)malloc(sizeof(stackList));  
  162.     int i = 0;  
  163.     k = g_stOperator;  
  164.     while(*p)  
  165.     {  
  166.         if((*p >= '0') && (*p <= '9'))  
  167.         {  
  168.             while((*p >= '0') && (*p <= '9'))  
  169.             {  
  170.                 suffixStr[i] = *p;  
  171.                 p++;  
  172.                 i++;  
  173.             }  
  174.             suffixStr[i++] = ',';  
  175.         }  
  176.         /*  
  177.             '+' -------  1 
  178.             '-' -------  2 
  179.             '*' -------  5 
  180.             '/' -------  6 
  181.         */  
  182.         if (*p == '+')  
  183.         {     
  184.             if ( ( isEmpty(g_stOperator) ) )  
  185.                 push(g_stOperator, 1);  
  186.             else if ( (g_stOperator->pNext->valueData - 1) > 2 )     
  187.             {  
  188.                 while ( !isEmpty(g_stOperator) )  
  189.                 {  
  190.                     switch ((int)g_stOperator->pNext->valueData)  
  191.                     {  
  192.                         case 1: suffixStr[i++] = '+'; suffixStr[i++] = ','break;  
  193.                         case 2: suffixStr[i++] = '-'; suffixStr[i++] = ','break;  
  194.                         case 5: suffixStr[i++] = '*'; suffixStr[i++] = ','break;  
  195.                         case 6: suffixStr[i++] = '/'; suffixStr[i++] = ','break;  
  196.                     }  
  197.                     pop(g_stOperator);    
  198.                 }  
  199.                 push(g_stOperator, 1);  
  200.             }  
  201.             else  
  202.                 push(g_stOperator, 1);  
  203.             p++;  
  204.         }  
  205.         if (*p == '-')  
  206.         {  
  207.             if ( ( isEmpty(g_stOperator) ) )  
  208.                 push(g_stOperator, 2);  
  209.             else if ( (g_stOperator->pNext->valueData - 1) > 2 )     
  210.             {  
  211.                 while ( !isEmpty(g_stOperator) )  
  212.                 {  
  213.                     switch ((int)g_stOperator->pNext->valueData)  
  214.                     {  
  215.                         case 1: suffixStr[i++] = '+'; suffixStr[i++] = ','break;  
  216.                         case 2: suffixStr[i++] = '-'; suffixStr[i++] = ','break;  
  217.                         case 5: suffixStr[i++] = '*'; suffixStr[i++] = ','break;  
  218.                         case 6: suffixStr[i++] = '/'; suffixStr[i++] = ','break;  
  219.                     }  
  220.                     pop(g_stOperator);    
  221.                 }  
  222.                 push(g_stOperator, 2);  
  223.             }  
  224.             else  
  225.                 push(g_stOperator, 2);  
  226.             p++;  
  227.         }  
  228.         if (*p == '*')  
  229.         {  
  230.             push(g_stOperator, 5);  
  231.             p++;  
  232.         }  
  233.         if (*p == '/')  
  234.         {  
  235.             push(g_stOperator, 6);  
  236.             p++;  
  237.         }  
  238.     }  
  239.     while ( !isEmpty(g_stOperator) )  
  240.     {  
  241.         switch ((int)g_stOperator->pNext->valueData)  
  242.         {  
  243.             case 1: suffixStr[i++] = '+'; suffixStr[i++] = ','break;  
  244.             case 2: suffixStr[i++] = '-'; suffixStr[i++] = ','break;  
  245.             case 5: suffixStr[i++] = '*'; suffixStr[i++] = ','break;  
  246.             case 6: suffixStr[i++] = '/'; suffixStr[i++] = ','break;  
  247.         }  
  248.         pop(g_stOperator);  
  249.     }  
  250. }  
  评论这张
 
阅读(108)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017