批处理版逆波兰四则计算器

老刘1号

特点：计算精确无误差。
例：(3*3*3/2)/((-9)/(11111*3*(1-99998/99999)))
VBS计算结果：-.499999999998098
该程序计算结果：-1/2

逆波兰四则计算器.bat

1. @Echo Off
   
2. Setlocal Enabledelayedexpansion
   
3. ::CODER BY 老刘 POWERD BY iBAT
   
4. Title 【老刘编写】逆波兰四则计算器
   
5. Path "%~dp0"
   
6. If Not Exist "Stack_LSS.Bat" (
   
7.         Echo "Stack_LSS"缺失！
   
8.         Pause&Exit
   
9. )
   
10. 
    
11. Set "Stack=Call Stack_LSS"
    
12. !Stack! :Init 运算符
    
13. !Stack! :Init 操作数
    
14. Echo Code By OldLiu
    
15. Echo.
    
16. Echo 表达式中只能出现“0123456789+-*/()”这些字符。
    
17. Echo 计算支持分数、括号可以嵌套。
    
18. Echo 支持负数，但负号前有运算符时需加括号。
    
19. Echo 错误举例：6/-3 5--3*-8
    
20. Echo 正确举例：6/(-3) 5-(-3*(-8))
    
21. Echo 输入Quit或Exit退出。
    
22. Echo.
    
23. Set /p IsDebug=是否开启DEBUG模式（y/n）：
    
24. If /i "!IsDebug!" Neq "y" (
    
25.         Set "Hide=Rem"
    
26. ) Else (
    
27.         Set "Hide="
    
28. )
    
29. 
    
30. :Loop
    
31.         Echo. & Set /p "中缀表达式=键入表达式>>> "
    
32.         If /i "!中缀表达式!" Equ "Quit" Exit
    
33.         If /i "!中缀表达式!" Equ "Exit" Exit
    
34.        
    
35.         Rem 中缀转后缀。
    
36.         !Stack! :Clear 运算符
    
37.         Set 后缀表达式=
    
38.         Set 可能出现负数=True
    
39.         :读取中缀表达式
    
40.         If "!中缀表达式!" == "" Goto 中缀转后缀完成
    
41.         Set "字符=!中缀表达式:~,1!"
    
42.         %Hide% Set 中缀表达式
    
43.         Set "中缀表达式=!中缀表达式:~1!"
    
44.        
    
45.         Rem 处理数字。
    
46.         Set /A "IsNum=!字符!" 2>Nul
    
47.         If "!IsNum!" EQU "!字符!" (
    
48.                 Set 数字=!数字!!字符!
    
49.                 Set 可能出现负数=False
    
50.                 Goto 读取中缀表达式
    
51.         ) Else (
    
52.                 If Defined 数字 (
    
53.                         Set "后缀表达式=!后缀表达式! !数字!"
    
54.                         %Hide% Set 后缀表达式
    
55.                         Set 数字=
    
56.                 )
    
57.         )
    
58.        
    
59.         Rem 处理左括弧。
    
60.         If "!字符!" == "(" (
    
61.                 Rem 左括弧不在栈中时优先级最高，直接压栈。
    
62.                 !Stack! :Push 运算符 字符
    
63.                 Set 可能出现负数=True
    
64.                 Goto 读取中缀表达式
    
65.         )
    
66. 
    
67.         Rem 处理右括弧。
    
68.         If "!字符!" == ")" (
    
69.                 Rem 运算符出栈，直到遇到左括弧。
    
70.                 :括弧中运算符输出
    
71.                 !Stack! :Pop 运算符 栈顶运算符
    
72.                 If "!栈顶运算符!" Neq "(" (
    
73.                         Set "后缀表达式=!后缀表达式! !栈顶运算符!"
    
74.                         %Hide% Set 后缀表达式
    
75.                         Goto 括弧中运算符输出
    
76.                 )
    
77.                 Goto 读取中缀表达式
    
78.         )
    
79.        
    
80.         Rem 处理运算符。
    
81.         If "!字符!" == "-" (
    
82.                 If !可能出现负数! == True (
    
83.                         Rem “-”号前面没数字，补一个“0”避免后缀表达式运算错误。
    
84.                         Set "后缀表达式=!后缀表达式! 0"
    
85.                         %Hide% Set 后缀表达式
    
86.                 )
    
87.         )
    
88.         !Stack! :IsEmpty 运算符
    
89.         If !ErrorLevel! Equ 0 (
    
90.                 Rem 栈是空的，任何运算符优先级高于空栈，入栈。
    
91.                 !Stack! :Push 运算符 字符
    
92.                 Goto 读取中缀表达式
    
93.         ) Else (
    
94.                 :运算符优先级比对
    
95.                 !Stack! :Pop 运算符 栈顶运算符
    
96.                 If !ErrorLevel! Equ 0 (
    
97.                         Set 优先级高=False
    
98.                         Rem 一切运算优先级高于栈中的左括弧。
    
99.                         If "!栈顶运算符!" == "(" Set 优先级高=True
    
100.                         Rem 乘除法优先级高于加减法。
     
101.                         If "!栈顶运算符!" == "+" (
     
102.                                 If "!字符!" == "*" Set 优先级高=True
     
103.                                 If "!字符!" == "/" Set 优先级高=True
     
104.                         )
     
105.                         If "!栈顶运算符!" == "-" (
     
106.                                 If "!字符!" == "*" Set 优先级高=True
     
107.                                 If "!字符!" == "/" Set 优先级高=True
     
108.                         )
     
109.                         If "!优先级高!" == "True" (
     
110.                                 Rem 当前运算优先级高于栈顶运算优先级，入栈。
     
111.                                 !Stack! :Push 运算符 栈顶运算符
     
112.                                 !Stack! :Push 运算符 字符
     
113.                                 Goto 读取中缀表达式
     
114.                         ) Else (
     
115.                                 Rem 当前运算优先级不高于栈顶运算优先级，栈顶的运算可以计算了。
     
116.                                 Set "后缀表达式=!后缀表达式! !栈顶运算符!"
     
117.                                 %Hide% Set 后缀表达式
     
118.                                 Rem 继续出栈，直到栈空或当前运算优先级高于栈顶运算。
     
119.                                 Goto 运算符优先级比对
     
120.                         )
     
121.                 ) Else (
     
122.                         Rem 栈已经清空，任何运算符优先级高于空栈，入栈。
     
123.                         !Stack! :Push 运算符 字符
     
124.                         Goto 读取中缀表达式
     
125.                 )
     
126.                 Echo 输入的表达式有误。
     
127.                 Goto Loop
     
128.         )
     
129.        
     
130.         :中缀转后缀完成
     
131.         Rem 写入最后一个数字。
     
132.         Set "后缀表达式=!后缀表达式! !数字!"
     
133.         Set 数字=
     
134.         Rem 弹出栈中所有运算符。
     
135.         !Stack! :Pop 运算符 栈顶运算符
     
136.         :运算符弹出
     
137.                 Set "后缀表达式=!后缀表达式! !栈顶运算符!"
     
138.                 !Stack! :Pop 运算符 栈顶运算符
     
139.         If !ErrorLevel! Equ 0 Goto 运算符弹出
     
140.         %Hide% Set 后缀表达式
     
141.        
     
142.         Rem 开始计算结果。
     
143.         !Stack! :Clear 操作数
     
144.         Call :计算结果 !后缀表达式!
     
145.         Goto 计算完成
     
146.         :计算结果
     
147.                 Set 字符=%1
     
148.                 Set /A "IsNum=!字符!" 2>Nul
     
149.                 If "!IsNum!" EQU "!字符!" (
     
150.                         Rem 数字入栈。
     
151.                         !Stack! :Push 操作数 字符
     
152.                 ) Else (
     
153.                         Rem 遇到运算符，计算。
     
154.                         Rem 从栈中弹出操作数，注意操作数2先出来。
     
155.                         !Stack! :Pop 操作数 操作数2
     
156.                         If !ErrorLevel! Neq 0 (
     
157.                                 Echo 输入的表达式有误。
     
158.                                 Goto Loop
     
159.                         )
     
160.                         !Stack! :Pop 操作数 操作数1
     
161.                         If !ErrorLevel! Neq 0 (
     
162.                                 Echo 输入的表达式有误。
     
163.                                 Goto Loop
     
164.                         )
     
165.                         Rem 整数转为分数。
     
166.                         If "!操作数1:/=!" Equ "!操作数1!" (
     
167.                                 Set "操作数1=!操作数1!/1"
     
168.                         )
     
169.                         If "!操作数2:/=!" Equ "!操作数2!" (
     
170.                                 Set "操作数2=!操作数2!/1"
     
171.                         )
     
172.                         Rem 进行运算。
     
173.                         If "!字符!" Equ "*" (
     
174.                                 Rem 分子互乘、分母互乘。
     
175.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数1!") do (
     
176.                                         Set /A 当前结果分子=%%a
     
177.                                         Set /A 当前结果分母=%%b
     
178.                                 )
     
179.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数2!") do (
     
180.                                         Set /A 当前结果分子*=%%a
     
181.                                         Set /A 当前结果分母*=%%b
     
182.                                 )
     
183.                         )
     
184.                         If "!字符!" Equ "/" (
     
185.                                 Rem 除以一个数等于乘其倒数。
     
186.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数1!") do (
     
187.                                         Set /A 当前结果分子=%%a
     
188.                                         Set /A 当前结果分母=%%b
     
189.                                 )
     
190.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数2!") do (
     
191.                                         Set /A 当前结果分子*=%%b
     
192.                                         Set /A 当前结果分母*=%%a
     
193.                                 )
     
194.                         )
     
195.                         Set 加减法=False
     
196.                         If "!字符!" Equ "+" Set 加减法=True
     
197.                         If "!字符!" Equ "-" Set 加减法=True
     
198.                         If "!加减法!" Equ "True" (
     
199.                                 Rem 母互乘子，并以为实，母相乘为法，实如法而一。
     
200.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数1!") do (
     
201.                                         Set /A 当前结果分子=%%a
     
202.                                         Set /A 当前结果分母=%%b
     
203.                                 )
     
204.                                 For /f "tokens=1,2 delims=/" %%a in ("!操作数2!") do (
     
205.                                         Set /A 当前结果分子=当前结果分子*%%b!字符!当前结果分母*%%a
     
206.                                         Set /A 当前结果分母*=%%b
     
207.                                 )
     
208.                         )
     
209.                         Rem 分数化简。
     
210.                         Set /A 被除数=当前结果分子,除数=当前结果分母
     
211.                         :求最大公约数
     
212.                                 If !除数! Equ 0 (
     
213.                                         Echo 除以0错误。
     
214.                                         Goto Loop
     
215.                                 )
     
216.                                 Set /A 余数=被除数%%除数
     
217.                         If !余数! Neq 0 (
     
218.                                 Set /A 被除数=除数,除数=余数
     
219.                                 Goto 求最大公约数
     
220.                         )
     
221.                         Rem 结果约分。
     
222.                         Set /A 当前结果分子/=除数,当前结果分母/=除数
     
223.                         Set 当前结果=!当前结果分子!/!当前结果分母!
     
224.                         %Hide% Echo ^(!操作数1!^)!字符!^(!操作数2!^)=!当前结果!
     
225.                         !Stack! :Push 操作数 当前结果
     
226.                 )
     
227.                 Shift /1
     
228.                 If "%1" Neq "" Goto 计算结果
     
229.         Goto :Eof
     
230.        
     
231.         :计算完成
     
232.         !Stack! :Pop 操作数 计算结果
     
233.         For /f "tokens=1,2 delims=/" %%a in ("!计算结果!") do (
     
234.                 Set /A 结果分子=%%a,结果分母=%%b
     
235.                 If !结果分母! Lss 0 Set /A 结果分子*=-1,结果分母*=-1
     
236.                 If !结果分子! Equ 0 (
     
237.                         Echo 结果：0
     
238.                 ) Else If !结果分母! Equ 1 (
     
239.                         Rem 结果为非0整数。
     
240.                         Echo 结果：!结果分子!
     
241.                 ) Else If !结果分子! Gtr !结果分母! (
     
242.                         Rem 结果大于1。
     
243.                         Set /A 商=结果分子/结果分母,余数=%%a%%结果分母
     
244.                         Echo 结果：!结果分子!/!结果分母!=!商!…!余数!
     
245.                 ) Else (
     
246.                         Rem 结果小于1。
     
247.                         Echo 结果：!结果分子!/!结果分母!
     
248.                 )
     
249.         )
     
250. Goto Loop

复制代码

Stack_LSS.BAT
计算测试（DEBUG模式开）

1. 键入表达式>>> (3*3*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
2. 中缀表达式=(3*3*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
3. 中缀表达式=3*3*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
4. 中缀表达式=*3*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
5. 后缀表达式= 3
   
6. 中缀表达式=3*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
7. 中缀表达式=*3/2)/((-9)/(11111*3*(1-99998/99999)))
   
8. 后缀表达式= 3 3
   
9. 后缀表达式= 3 3 *
   
10. 中缀表达式=3/2)/((-9)/(11111*3*(1-99998/99999)))
    
11. 中缀表达式=/2)/((-9)/(11111*3*(1-99998/99999)))
    
12. 后缀表达式= 3 3 * 3
    
13. 后缀表达式= 3 3 * 3 *
    
14. 中缀表达式=2)/((-9)/(11111*3*(1-99998/99999)))
    
15. 中缀表达式=)/((-9)/(11111*3*(1-99998/99999)))
    
16. 后缀表达式= 3 3 * 3 * 2
    
17. 后缀表达式= 3 3 * 3 * 2 /
    
18. 中缀表达式=/((-9)/(11111*3*(1-99998/99999)))
    
19. 中缀表达式=((-9)/(11111*3*(1-99998/99999)))
    
20. 中缀表达式=(-9)/(11111*3*(1-99998/99999)))
    
21. 中缀表达式=-9)/(11111*3*(1-99998/99999)))
    
22. 后缀表达式= 3 3 * 3 * 2 / 0
    
23. 中缀表达式=9)/(11111*3*(1-99998/99999)))
    
24. 中缀表达式=)/(11111*3*(1-99998/99999)))
    
25. 后缀表达式= 3 3 * 3 * 2 / 0 9
    
26. 后缀表达式= 3 3 * 3 * 2 / 0 9 -
    
27. 中缀表达式=/(11111*3*(1-99998/99999)))
    
28. 中缀表达式=(11111*3*(1-99998/99999)))
    
29. 中缀表达式=11111*3*(1-99998/99999)))
    
30. 中缀表达式=1111*3*(1-99998/99999)))
    
31. 中缀表达式=111*3*(1-99998/99999)))
    
32. 中缀表达式=11*3*(1-99998/99999)))
    
33. 中缀表达式=1*3*(1-99998/99999)))
    
34. 中缀表达式=*3*(1-99998/99999)))
    
35. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111
    
36. 中缀表达式=3*(1-99998/99999)))
    
37. 中缀表达式=*(1-99998/99999)))
    
38. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3
    
39. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 *
    
40. 中缀表达式=(1-99998/99999)))
    
41. 中缀表达式=1-99998/99999)))
    
42. 中缀表达式=-99998/99999)))
    
43. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1
    
44. 中缀表达式=99998/99999)))
    
45. 中缀表达式=9998/99999)))
    
46. 中缀表达式=998/99999)))
    
47. 中缀表达式=98/99999)))
    
48. 中缀表达式=8/99999)))
    
49. 中缀表达式=/99999)))
    
50. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998
    
51. 中缀表达式=99999)))
    
52. 中缀表达式=9999)))
    
53. 中缀表达式=999)))
    
54. 中缀表达式=99)))
    
55. 中缀表达式=9)))
    
56. 中缀表达式=)))
    
57. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999
    
58. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999 /
    
59. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999 / -
    
60. 中缀表达式=))
    
61. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999 / - *
    
62. 中缀表达式=)
    
63. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999 / - * /
    
64. 后缀表达式= 3 3 * 3 * 2 / 0 9 - 11111 3 * 1 99998 99999 / - * /  /
    
65. (3/1)*(3/1)=9/1
    
66. (9/1)*(3/1)=27/1
    
67. (27/1)/(2/1)=27/2
    
68. (0/1)-(9/1)=-9/1
    
69. (11111/1)*(3/1)=33333/1
    
70. (99998/1)/(99999/1)=99998/99999
    
71. (1/1)-(99998/99999)=1/99999
    
72. (33333/1)*(1/99999)=1/3
    
73. (-9/1)/(1/3)=-27/1
    
74. (27/2)/(-27/1)=1/-2
    
75. 结果：-1/2

复制代码