Transformation of infix expressions and prefix expressions

Infix expression: the operator is placed in the middle of two calculation objects, for example: (2 + 1) * 3;

Suffix expression: contains no parentheses. Operators are placed behind two calculation objects. All calculation operations are performed strictly from left to right according to the order in which operators appear (the priority rules of operators are not considered, for example: 2 1 + 3 *;

Prefix expression: Like a suffix expression, it does not contain parentheses. The operator is placed before two calculation objects, for example, * + 2 1 3.

Lab Purpose

1. Familiar with Stack applications

2. Familiar with the transformation from an infix expression to a prefix

Lab content

1. Write a program to convert an infix expression to a prefix.

For example, 2*3/(2-1) + 5 * (4-1) is converted to +/* 23-21*5-41

// Replace /*

Reference Algorithm

1) Calculate the reverse order of the input string.

2) Check the next element of the input.

3) Add the operand to the output string.

4) if the brackets are closed, press them on the stack.

5) if it is an operator, then

I) If the stack is empty, this operator is used to import data to the stack.

Ii) if the top of the stack is closed brackets, this operator is used to import the stack.

Iii) if its priority is higher than or equal to the stack top operator, this operator is added to the stack.

Iv) otherwise, the stack top operator goes out of the stack and is added to the output string. Repeat Step 5.

6) For example, the operators in the stack exit the stack one by one and output them until brackets are closed. Close the brackets out of the stack and discard them.

7) if the input is not complete, jump to step 2.

8) If the input is complete, all operators in the stack are output from the stack and added to the output string.

9) returns the reverse order of the output string. */

Code:

1. # Include <iostream>
2. # Include <string>
3. Using namespace STD;
4. Char stack [50]; // defines the ordered stack. The first element indicates that the stack is empty;
5. Int Top = 0; // stack top pointer. If it is 0, the stack is empty;
6. Int level (char OP) // determines the operator level function. The */level is 2, and the +-level is 1;
7. {
8. Int level;
9. Switch (OP)
10. {
11. Case '+ ':
12. Case '-': Level = 1; break;
13. Case '*':
14. Case '/': Level = 2; break;
15. Default: Level = 0; break;
16. }
17. Return level;
18. }
19. Bool isoperator (char OP) // determines whether the character in the input string is an operator. If yes, true is returned.
20. {
21. If (OP = '+' | op = '-' | op = '*' | op = '/')
22. Return true;
23. Else
24. Return false;
25. }
26. String convert (string s) // converts an infix string to a suffix string,
27. {
28. String output = ""; // output string
29. For (INT I = S. Length ()-1; I> = 0;) // 1) returns the reverse order of the input string.
30. {
31. If (s [I]> = 48 & S [I] <= 57)
32. Output = output + s [I]; // 3) Add the operand to the output string.
33. If (s [I] = ') // 4) if it is a closed bracket, press it on the stack.
34. {
35. Top ++;
36. Stack [Top] = s [I];
37. }
38. While (isoperator (s [I]) // if it is an operator, execute the corresponding operation of the algorithm (5;
39. {
40. If (Top = 0 | stack [Top] = ')' | level (s [I])> = level (stack [Top])
41. {
42. Top ++;
43. Stack [Top] = s [I];
44. Break;
45. }
46. Else
47. {
48. Output = output + stack [Top];
49. Top --;
50. }
51. }
52. If (s [I] = '(') // 6) for example, if it is an open bracket, the operators in the stack are output one by one and output until parentheses are closed. Close the brackets out of the stack and discard them.
53. {
54. While (stack [Top]! = ')')
55. {
56. Output = output + stack [Top];
57. Top --;
58. }
59. Top --;
60. }
61. I --; // 7) if the input is not complete, jump to step 2.
62. }
63. While (top! = 0) // 8) If the input is complete, all the operators remaining in the stack go out of the stack and add them to the output string.
64. {
65. Output = output + stack [Top];
66. Top --;
67. }
68. Return output;
69. }
70. Int main ()
71. {
72. String input, output;
73. Cout <"Enter the string :";
74. Cin> input;
75. Output = convert (input );
76. Cout <"Suffix :";
77. For (INT I = output. Length ()-1; I> = 0; I --) // 9) returns the reverse order of the output string.
78. Cout <output [I];
79. Cout <Endl;
80. Return 0;
81. }