使用数据结构中的栈以及链表来制作一个能够处理中缀表达式的计算程序。
在该程序中输入的数字可以是任意正数、小数。（忘了添加对负数的支持，尽快补上）
输入的运算符可以是 + - * / ( )
但请确保输入的表达式合法。
中缀表达式：
形如
9+(3-1)*3+10/2
的数学表达式。特点是运算符在被运算的两个数字中间，也就是我们日常接触的算式。
后缀表达式：
以上面的中缀表达式 9+(3-1)*3+10/2 为例
转换成后缀表达式为 9 3 1-3*+ 10 2/+
特点是运算符紧跟在被运算的两个数之后，这样方便程序的理解与计算。
只要顺序读取数字并根据其后的运算符进行相应的操作即可得到结果。
对于以上的转换如有不懂可参考
程序大致分为3步实现：
1）将输入的字符串拆分为数字与运算符，用一个链表储存它们，方便接下来的计算
2）使用仅储存运算符的栈将该中缀表达式转换为后缀表达式
3）使用仅储存数字的栈来运算后缀表达式得到最终答案
为实现这3步，代码有点繁琐。。。用了多个文件来分别实现具体功能
以下是各个代码及大概作用，由于比较长，全部折叠了。
Stack.h & Stack.c
实现了一个储存运算符的栈（用于进行第2步）和一个储存数字的栈（用于第3步）
1 //////////////
2 // Stack.h //
3 //////////////
4
5 #ifndef _STACK_H_
6 #define _STACK_H_
7
8 #include<stdlib.h>
9
10 #define STACK_INIT_SIZE 10
11 #define STACKINCREMENT 10
12
13 //优先级的定义
14 #define TopLow -1
15 #define Equal 0
16 #define TopHigh 1
17 //输入的是个括号
18 #define InputIsBrace_1 2
19 #define InputIsBrace_2 3
20 //当前栈顶是个括号
21 #define TopIsBrace 4
22
23 typedef char SymType;
24 typedef float NumType;
25
26 //第一步
27 //将中缀表达式转换为后缀表达式
28 //该栈用于储存符号
29 struct _Operator
30 {
31 SymType *Top,*Bottom;
32 int stacksize;
33 };
34 typedef struct _Operator OPERATOR;
35
36 //新建栈
37 int InitStack_O(OPERATOR *S);
38
39 //销毁栈
40 int DestroyStack_O(OPERATOR *S);
41
42 //检测栈是否为空
43 //返回1表示为空
44 int StackEmpty_O(OPERATOR S);
45
46 //获取栈顶部元素
47 SymType GetTop_O(OPERATOR S);
48
49 //与栈顶的优先级进行比较
50 int TopIsPriority_O(OPERATOR S, SymType Input,SymType Top);
51
52 //Push操作，入栈，压栈
53 int Push_O(OPERATOR *S, SymType e);
54
55 //Pop操作，出栈
56 SymType Pop_O(OPERATOR *S);
57
58 //以上为符号栈
59 //=====================================================================
60 //以下为数字栈
61
62 //第二步
63 //计算后缀表达式的值
64 //用于储存数据
65 struct _Number
66 {
67 NumType *Top, *Bottom;
68 int stacksize;
69 };
70 typedef struct _Number NUMBER;
71
72 //新建栈
73 int InitStack_N(NUMBER *S);
74
75 //销毁栈
76 int DestroyStack_N(NUMBER *S);
77
78 //获取栈顶部元素
79 NumType GetTop_N(NUMBER S);
80
81 //Push操作，入栈，压栈
82 int Push_N(NUMBER *S, NumType e);
83
84 //Pop操作，出栈
85 NumType Pop_N(NUMBER *S);
86
87 //接受运算符
88 //取栈顶的两个数字
89 //进行相应运算
90 void DoTheMath(NUMBER*,char);
91
92 #endif
Stack.h
1 //////////////
2 // Stack.c //
3 /////////////
4
5 #include"Stack.h"
6
7 int InitStack_O(OPERATOR *S)
8 {
9 //创建出设定长度的顺序表，地址赋给bottom指针
10 S->Bottom = (SymType*)malloc(STACK_INIT_SIZE*sizeof(SymType));
11 if (!S->Bottom)
12 {
13 return 0;
14 }
15 S->stacksize = STACK_INIT_SIZE;
16 S->Top = S->Bottom;
17 return 1;
18 }
19
20 int DestroyStack_O(OPERATOR *S)
21 {
22 S->Top = NULL;
23 free(S->Bottom);
24 S->Bottom = NULL;
25 return 1;
26 }
27
28 int StackEmpty_O(OPERATOR S)
29 {
30 if (S.Bottom == S.Top)
31 {
32 return 1;
33 }
34 else
35 {
36 return 0;
37 }
38 }
39
40 SymType GetTop_O(OPERATOR S)
41 {
42 if (S.Bottom != S.Top)
43 {
44 //由于top指向的是最顶上元素的下一个位置
45 //所以取出最顶上元素的时候
46 //要把top减去1
47 return *(S.Top - 1);
48 }
49 return 0;
50 }
51
52 //与栈顶的优先级进行比较
53 int TopIsPriority_O(OPERATOR S, SymType Input,SymType top)
54 {
55 if (Input == ‘(‘)
56 {
57 return InputIsBrace_1;
58 }
59 if (Input == ‘)‘)
60 {
61 return InputIsBrace_2;
62 }
63 if (top == ‘(‘)
64 {
65 return TopIsBrace;
66 }
67 //-+优先级为1
68 //*/优先级为2
69 int p_top, p_input;
70 if (top == ‘-‘ || top == ‘+‘)
71 {
72 p_top = 1;
73 }
74 if (top == ‘*‘ || top == ‘/‘)
75 {
76 p_top = 2;
77 }
78 if (Input == ‘-‘ || Input == ‘+‘)
79 {
80 p_input = 1;
81 }
82 if (Input == ‘*‘ || Input == ‘/‘)
83 {
84 p_input = 2;
85 }
86
87 if (p_input > p_top)
88 {
89 return TopLow;
90 }
91 if (p_input == p_top)
92 {
93 return Equal;
94 }
95 if (p_input < p_top)
96 {
97 return TopHigh;
98 }
99 return 0;
100 }
101
102 int Push_O(OPERATOR *S, SymType e)
103 {
104 //当超出当前栈的容量时进行扩容
105 //这里应该只有等于的情况
106 //而不会大于
107 if ((S->Top - S->Bottom) >= S->stacksize)
108 {
109 //realloc函数将开辟指定大小的储存空间
110 //并将原来的数据全部移到这个新的储存空间
111 S->Bottom = (SymType*)realloc(S->Bottom, (S->stacksize + STACKINCREMENT)*sizeof(SymType));
112 if (!S->Bottom)
113 {
114 return 0;
115 }
116 //由于重新开辟了空间
117 //需要重新根据bottom指针的位置指定top
118 S->Top = S->Bottom + S->stacksize;
119 //最后增加当前栈容量
120 S->stacksize += STACKINCREMENT;
121 }
122 //再把入栈的数据存放好
123 *(S->Top++) = e;
124 return 1;
125 }
126
127 SymType Pop_O(OPERATOR *S)
128 {
129 if (S->Bottom == S->Top)
130 {
131 return 0;
132 }
133 //top指针先减1再取值
134 return *(--S->Top);
135 }
136
137 //以上为符号栈的函数
138 //========================================================================
139 //以下为数字栈的函数
140
141 int InitStack_N(NUMBER *S)
142 {
143 //创建出设定长度的顺序表，地址赋给bottom指针
144 S->Bottom = (NumType*)malloc(STACK_INIT_SIZE*sizeof(NumType));
145 if (!S->Bottom)
146 {
147 return 0;
148 }
149 S->stacksize = STACK_INIT_SIZE;
150 S->Top = S->Bottom;
151 return 1;
152 }
153
154 int DestroyStack_N(NUMBER *S)
155 {
156 S->Top = NULL;
157 free(S->Bottom);
158 S->Bottom = NULL;
159 return 1;
160 }
161
162 NumType GetTop_N(NUMBER S)
163 {
164 if (S.Bottom != S.Top)
165 {
166 //由于top指向的是最顶上元素的下一个位置
167 //所以取出最顶上元素的时候
168 //要把top减去1
169 return *(S.Top - 1);
170 }
171 return 0;
172 }
173
174 int Push_N(NUMBER *S, NumType e)
175 {
176 //当超出当前栈的容量时进行扩容
177 //这里应该只有等于的情况
178 //而不会大于
179 if ((S->Top - S->Bottom) >= S->stacksize)
180 {
181 //realloc函数将开辟指定大小的储存空间
182 //并将原来的数据全部移到这个新的储存空间
183 S->Bottom = (NumType*)realloc(S->Bottom, (S->stacksize + STACKINCREMENT)*sizeof(NumType));
184 if (!S->Bottom)
185 {
186 return 0;
187 }
188 //由于重新开辟了空间
189 //需要重新根据bottom指针的位置指定top
190 S->Top = S->Bottom + S->stacksize;
191 //最后增加当前栈容量
192 S->stacksize += STACKINCREMENT;
193 }
194 //再把入栈的数据存放好
195 *(S->Top++) = e;
196 return 1;
197 }
198
199 NumType Pop_N(NUMBER * S)
200 {
201 if (S->Bottom == S->Top)
202 {
203 return 0;
204 }
205 //top指针先减1再取值
206 return *(--S->Top);
207 }
208
209 void DoTheMath(NUMBER *S,char sym)
210 {
211 //从栈顶顺序读入两个数字
212 //进行运算
213 //并将结果压回栈内
214 float num1, num2;
215 num2 = Pop_N(S);
216 num1 = Pop_N(S);
217 switch (sym)
218 {
219 case ‘+‘:
220 Push_N(S, num1 + num2);
221 break;
222 case ‘-‘:
223 Push_N(S, num1 - num2);
224 break;
225 case ‘*‘:
226 Push_N(S, num1*num2);
227 break;
228 case ‘/‘:
229 Push_N(S, num1 / num2);
230 break;
231 default:
232 break;
233 }
234 }
Stack.c
StringToNumAndSym.h & StringToNumAndSym.c
这个文件的功能是。。。。
将输入的一大串字符串拆分成一个数字或一个运算符，并将他们按顺序储存到一个链表里。
用于进行第1步。
1 ////////////////////////////////
2 //StringToNumAndSym.h//
3 ///////////////////////////////
4
5 #ifndef _STRINGTONUMANDSYM_H_
6 #define _STRINGTONUMANDSYM_H_
7
8 #include<stdlib.h>
9
10 //用于储存输入的数字或者符号
11 //IsNum=1 将读取数字
12 //IsNum=0 将读取字符
13 struct data_node
14 {
15 int IsNum;
16 float Num;
17 char Sym;
18 struct data_node *next;
19 };
20 typedef struct data_node EQUATION;
21
22 //该函数接受输入的字符串
23 //输出一串处理好的等式的指针
24 //用于表示数字或者运算符号加减乘除等等
25 void StringToEquation(char *,EQUATION**);
26
27 void DestroyEquation(EQUATION*);
28
29 #endif
StringToNumAndSym.h
1 /////////////////////////////////
2 // StringToNumAndSym.c //
3 ///////////////////////////////
4
5 #include"StringToNumAndSym.h"
6
7 void StringToEquation(char *input, EQUATION **ptr_source)
8 {
9 EQUATION *ptr = NULL;
10 int lop;
11 //记录正数部分的temp
12 int Ptmp;
13 //记录小数部分的temp
14 float Dtmp;
15 //PNum记录正数的位数
16 //NNum记录小数的个数
17 float Dmulti;
18 int Pmulti;
19
20 for (lop = 0; input[lop] != 0; lop++)
21 {
22 //接下来有个数字
23 //除错，确保输入合法
24 if (input[lop] >= ‘0‘ && input[lop] <= ‘9‘
25 || input[lop] == ‘+‘ || input[lop] == ‘-‘ || input[lop] == ‘/‘ || input[lop] == ‘*‘
26 || input[lop] == ‘(‘ || input[lop] == ‘)‘ || input[lop] == ‘.‘)
27 {
28 if (input[lop] >= ‘0‘ && input[lop] <= ‘9‘)
29 {
30 Ptmp = 0;
31 Dtmp = 0;
32 Pmulti = 1;
33 Dmulti = 1;
34
35 //计算整数部分
36 for (; input[lop] >= ‘0‘ && input[lop] <= ‘9‘; lop++)
37 {
38 Ptmp = Ptmp * 10 + (input[lop] - ‘0‘);
39 }
40
41 //如果有小数
42 //计算小数部分
43 if (input[lop] == ‘.‘)
44 {
45 Dmulti = (float)0.1;
46 //计算出小数部分
47 for (lop += 1; input[lop] >= ‘0‘ && input[lop] <= ‘9‘; lop++)
48 {
49 Dtmp += Dmulti*(float)(input[lop] - ‘0‘);
50 Dmulti *= (float)0.1;
51 }
52 }
53 //得到数字了
54 //创建节点保存
55 if (ptr == NULL)
56 {
57 ptr = (EQUATION*)malloc(sizeof(EQUATION));
58 //创建第一个节点之后
59 //由于传入的是指针的指针
60 //需要更改ptr_source的值
61 //保存头指针
62 *ptr_source = ptr;
63 }
64 else
65 {
66 ptr->next = (EQUATION*)malloc(sizeof(EQUATION));
67 ptr = ptr->next;
68 }
69 ptr->next = NULL;
70 ptr->IsNum = 1;
71 ptr->Num = (float)Ptmp + Dtmp;
72 ptr->Sym = ‘0‘;
73
74 lop--;
75 }
76 else
77 {
78 //第一个节点
79 if (ptr == NULL)
80 {
81 ptr = (EQUATION*)malloc(sizeof(EQUATION));
82 *ptr_source = ptr;
83 }
84 //之后的节点
85 else
86 {
87 ptr->next = (EQUATION*)malloc(sizeof(EQUATION));
88 ptr = ptr->next;
89 }
90 ptr->next = NULL;
91 ptr->IsNum = 0;
92 ptr->Num = 0;
93 ptr->Sym = input[lop];
94 }
95 }
96 }
97 }
98
99 /*
100 //反转整数
101 int Invert(int input)
102 {
103 int output = 0;
104 while (input > 0)
105 {
106 output = output * 10 + input % 10;
107 input /= 10;
108 }
109 return output;
110 }
111 */
112
113 void DestroyEquation(EQUATION *N)
114 {
115 EQUATION *temp = NULL;
116 if (N != NULL)
117 {
118 temp = N;
119 N = N->next;
120 free(temp);
121 temp = NULL;
122
123 DestroyEquation(N);
124 }
125 }
StringToNumAndSym.c
main.c
主函数在此，实现了判断运算符运算顺序的逻辑
1 /////////////
2 // main.c //
3 /////////////
4
5 #include<stdio.h>
6
7 #include"Stack.h"
8 #include"StringToNumAndSym.h"
9
10 int main()
11 {
12 int lop = 0;
13
14 //新建用于储存输入数据的字符串
15 char string[30] = { 0 };
16 //新建用于储存处理后数据的字符串
17 EQUATION *Eqinput;
18
19 //以下4行创建并初始化两个栈
20 //分别用于存放运算符和数字
21 OPERATOR Stack_Ope;
22 NUMBER Stack_Num;
23
24 InitStack_O(&Stack_Ope);
25 InitStack_N(&Stack_Num);
26
27 //输入合法的中缀表达式
28 //不要太长
29 printf("请输入合法的中缀表达式:\n");
30 scanf("%s", string);
31
32 //将输入的字符串转化为能够处理的数据
33 StringToEquation(string, &Eqinput);
34
35 //将中缀表达式转换为后缀表达式
36 //同时包含对数据的运算
37
38 //如果输入的数据还没有处理完
39 while (Eqinput != NULL)
40 {
41 //看看当前对象是不是数字
42 if (Eqinput->IsNum == 1)
43 {
44 //是数字就直接丢到处理数字的栈里去
45 Push_N(&Stack_Num, Eqinput->Num);
46 }
47 else
48 {
49 if (StackEmpty_O(Stack_Ope))
50 {
51 Push_O(&Stack_Ope, Eqinput->Sym);
52 }
53
54 //是运算符的话
55 //将他与上一个运算符，也就是栈顶的那个运算符进行比较
56 //然后根据两者的优先级大小来做出相应操作
57 else
58 {
59 //优先级判断
60 switch (TopIsPriority_O(Stack_Ope,Eqinput->Sym,GetTop_O(Stack_Ope)))
61 {
62 //如果栈顶是括号
63 //不进行优先级的比较
64 //直接入栈
65 case TopIsBrace:
66 Push_O(&Stack_Ope, Eqinput->Sym);
67 break;
68
69 //输入了左括号
70 case InputIsBrace_1:
71 Push_O(&Stack_Ope, ‘(‘);
72 break;
73
74 //输入了右括号
75 //一直出栈
76 //直到遇到左括号
77 case InputIsBrace_2:
78 while((GetTop_O(Stack_Ope) != ‘(‘))
79 {
80 //printf("%c ", Pop_O(&Stack_Ope));
81 DoTheMath(&Stack_Num, Pop_O(&Stack_Ope));
82 }
83 Pop_O(&Stack_Ope);
84 break;
85
86 //当前运算符优先级比栈顶的低或者相等
87 case TopHigh:
88 case Equal:
89 while (!StackEmpty_O(Stack_Ope))
90 {
91 //printf("%c ", Pop_O(&Stack_Ope));
92 DoTheMath(&Stack_Num, Pop_O(&Stack_Ope));
93 }
94 Push_O(&Stack_Ope, Eqinput->Sym);
95 break;
96
97 //当前运算符优先级比栈顶的高
98 case TopLow:
99 Push_O(&Stack_Ope, Eqinput->Sym);
100 break;
101 default:
102 break;
103 }
104 }
105 }
106 //读入下一个数据
107 Eqinput = Eqinput->next;
108 }
109
110 //如果栈里还有残留的运算符
111 //全部出栈
112 while (!StackEmpty_O(Stack_Ope))
113 {
114 //printf("%c ", Pop_O(&Stack_Ope));
115 DoTheMath(&Stack_Num, Pop_O(&Stack_Ope));
116 }
117
118 printf("\n");
119
120 //////////////
121 //运算完毕//
122 /////////////
123
124 printf("%s = %.3f\n", string, GetTop_N(Stack_Num));
125
126 //销毁输入的式子
127 DestroyEquation(Eqinput);
128 Eqinput = NULL;
129
130 DestroyStack_N(&Stack_Num);
131 DestroyStack_O(&Stack_Ope);
132
133 return 0;
134 }
main.c
时间： 2024-08-19 04:05:11