四则运算

牡丹花下死做鬼

今天开始学习栈了了解了下什么叫做栈说就是一种特殊点的线性表什么什么的，大概有点了解了然后书上介绍了四则运算的方法，先把输入的四则运算改成后缀式，最后计算。具体算法大家自己百度把，看起来好像不是很难于是乎我开始动手写了，按照自己的想法写完之后开心的按下了Ctrl+ F5 结果一堆BUG和error 弄了三个小时终于是实现功能了，当然还是很不完善，大牛勿喷。

1. #include<stdio.h>//9+(3-1)*3+10/2
   
2. #include<windows.h>
   
3. //#include<string.h>
   
4. 
   
5. int main()
   
6. {
   
7.         char str[100] = { '\n' };
   
8.         char temp[100] = { '\n' };
   
9.         char ch,t;
   
10.         int calc[50];
    
11.         int i = 0, j = 0, k, l = 0;
    
12.         t = '\n';
    
13.         printf("请输入一个四则混合运算:");
    
14.         //开始处理原式
    
15.         while ((ch = getchar()) != '\n')//一个一个的读取输入的字符
    
16.         {
    
17.                 if (ch == '(')//如果是'('直接压栈
    
18.                 {
    
19.                         temp[i] = ch;
    
20.                         i++;
    
21.                 }
    
22.                 else if(ch == ')')//如果是')'就把栈顶元素输出到后缀表达式存放数组str 直到栈顶元素为'('
    
23.                 {
    
24.                         while (temp[i-1]!='(')
    
25.                         {
    
26.                                 if (i == 0)//')'个数多于'('
    
27.                                 {
    
28.                                         printf("括号不匹配!\n");
    
29.                                         system("pause");
    
30.                                         return 0;
    
31.                                 }
    
32.                                 str[j] = ' ';//数字数字符号符号直接全部加上空格为了防止123不知道是1 2 3 还是12 3 这种情况
    
33.                                 j++;
    
34.                                 str[j] = temp[i - 1]; //把栈顶元素输出到后缀表达式存放数组str
    
35.                                 i--;
    
36.                                 j++;
    
37.                         }
    
38.                         i--;
    
39.                 }
    
40.                 else if(ch == '*' || ch == '/')//如果是'*' 或者 '/'
    
41.                 {
    
42.                         if (!(t == '+' || t == '-' || t == '*' || t == '/')) //判断是否连续输入符号 如5 ++ 6
    
43.                         {
    
44.                                 str[j] = ' ';
    
45.                                 j++;
    
46.                                 while (temp[i - 1] == '*' || temp[i - 1] == '/') //只要优先级没有比栈顶的高就出栈直到优先级高于栈顶的或者栈顶为'('
    
47.                                 {
    
48.                                         str[j] = ' ';
    
49.                                         j++;
    
50.                                         str[j] = temp[i - 1];
    
51.                                         i--;
    
52.                                         j++;
    
53.                                 }
    
54.                                 temp[i] = ch;//最后再压栈
    
55.                                 i++;
    
56.                         }
    
57.                         else
    
58.                         {
    
59.                                 printf("不能连续输入运算符号!\n!");
    
60.                                 system("pause");
    
61.                                 return 0;
    
62.                         }
    
63.                 }
    
64.                 else if(ch == '+' || ch == '-')//如果是'+' 或者 '-'
    
65.                 {
    
66.                         str[j] = ' ';
    
67.                         j++;
    
68.                         if (!(t == '+' || t == '-' || t == '*' || t == '/'))
    
69.                         {
    
70.                                 while (temp[i - 1] != '(' && i>0) //优先级最低了所以除非栈顶是'('否则全部出栈
    
71.                                 {
    
72.                                         str[j] = ' ';
    
73.                                         j++;
    
74.                                         str[j] = temp[i - 1];
    
75.                                         i--;
    
76.                                         j++;
    
77.                                 }
    
78.                                 temp[i] = ch;
    
79.                                 i++;
    
80.                         }
    
81.                         else
    
82.                         {
    
83.                                 printf("不能连续输入运算符号!\n!");
    
84.                                 system("pause");
    
85.                                 return 0;
    
86.                         }
    
87.                 }
    
88.                 else if (ch >= '0' && ch <= '9') // 如果是数字直接输出到后缀表达式存放数组str
    
89.                 {
    
90.                         str[j] = ch;
    
91.                         j++;
    
92.                 }
    
93.                 else
    
94.                 {
    
95.                         printf("存在非法字符!\n");
    
96.                         system("pause");
    
97.                         return 0;
    
98.                 }
    
99.                 t = ch;
    
100.         }
     
101. 
     
102.         while (i>0)
     
103.         {
     
104.                 if (temp[i - 1] != '(')//把栈中的全部输出到后缀表达式存放数组str
     
105.                 {
     
106.                         str[j] = ' ';
     
107.                         j++;
     
108.                         str[j] = temp[i - 1];
     
109.                         i--;
     
110.                         j++;
     
111.                 }
     
112.                 else//'('个数多
     
113.                 {
     
114.                         printf("括号不匹配!\n");
     
115.                         system("pause");
     
116.                         return 0;
     
117.                 }
     
118.         }
     
119.         k = 0;
     
120.         /*
     
121.         for (i = 0; i < j; i++)
     
122.         {
     
123.                 printf("%c",str[i]);
     
124.         }
     
125.         */
     
126.         for (i = 0; i < j; i++) // 还要对后缀表达式进行处理把  '3''8' 变成 38 储存以用于计算
     
127.         {
     
128.                 if (str[i] >= '0' && str[i] <= '9') //如果是数字
     
129.                 {
     
130.                         if (str[i + 1] != ' ') //判断下一个是不是空格
     
131.                         {
     
132.                                 k = k * 10 + (str[i] - 48);//如果不是说明类似于123 是123 不是1 2 3 现在读取的1还不是结果 进行计算
     
133.                         }
     
134.                         else//如果是空格
     
135.                         {
     
136.                                 if (k == 0)//判断是不是一位数(数字是就是0哪边都可以)
     
137.                                 {
     
138.                                         calc[l] = str[i] - 48;//是一位数就直接保存当前数字
     
139.                                 }
     
140.                                 else
     
141.                                 {
     
142.                                         k = k * 10 + (str[i] - 48);//不是进行最后一次运算得到结果在保存 并初始化K
     
143.                                         calc[l] = k;
     
144.                                         k = 0;
     
145.                                 }
     
146.                                 l++;
     
147.                                
     
148.                                 while (str[i + 1] == ' ')//清理空格
     
149.                                 {
     
150.                                         i++;
     
151.                                 }
     
152.                         }
     
153.                 }
     
154.                 //至此对原式的处理全部完毕
     
155.                 //开始计算 算法自己百度
     
156.                 else if (str[i] == '+')
     
157.                 {
     
158.                         l = l - 1;
     
159.                         calc[l-1] = calc[l-1] + calc[l ];
     
160.                 }
     
161.                 else if(str[i] == '-')
     
162.                 {
     
163.                         l = l - 1;
     
164.                         calc[l-1] = calc[l-1] - calc[l];
     
165.                 }
     
166.                 else if (str[i] == '*')
     
167.                 {
     
168.                         l = l - 1;
     
169.                         calc[l-1] = calc[l-1] * calc[l];
     
170.                 }
     
171.                 else if (str[i] == '/')
     
172.                 {
     
173.                         l = l - 1;
     
174.                         calc[l-1] = calc[l-1] / calc[l];
     
175.                 }
     
176.                 else
     
177.                 {
     
178.                         while (str[i + 1] == ' ')
     
179.                         {
     
180.                                 i++;
     
181.                         }
     
182.                 }
     
183.         }
     
184.         printf("结果是:%d\n", calc[l-1]);
     
185.         system("pause");
     
186. 
     
187.         return 0;
     
188. }

复制代码

我爱软件开发

C++里面有专门讲这个的