中缀转后缀(Infix2Postfix.c)

spy

1. #include <stdio.h>
   
2. #include <malloc.h>
   
3. #include <stdlib.h>
   
4. #include <ctype.h>
   
5. #include <conio.h>
   
6. #include <math.h>
   
7. 
   
8. /*
   
9. 算法的基本思想是:
   
10.         顺序扫描键盘缓冲区中输入的中缀表达式，读到操作数时，直接将其存放至操作数队列
    
11.         读到运算符时，将操作符栈中所有优先级高于或等于该运算符的运算符弹出栈，
    
12.         并将其存放至操作数队列，然后在将读入的运算符入栈
    
13.         当读入左括号时直接入栈；
    
14.         当读到右括号时，将与靠近栈顶的第一个左括号之间的运算符全部依次弹出栈，存放至输出队列
    
15. */
    
16. 
    
17. struct StackNode
    
18. {
    
19.         char data;
    
20.         struct StackNode* next;
    
21. };
    
22. void Push(struct StackNode** top, char data);
    
23. char Pop(struct StackNode** top);
    
24. char GetTop(struct StackNode* top);
    
25. 
    
26. struct QueueNode
    
27. {
    
28.         float data;
    
29.         struct QueueNode* next;
    
30. };
    
31. void InitQueue(struct QueueNode** front, struct QueueNode** rear);
    
32. void EnQueue(struct QueueNode** rear, float data);
    
33. float DeQueue(struct QueueNode* front, struct QueueNode** rear);
    
34. void QueueTraverse(struct QueueNode* front);
    
35. void DestroyQueue(struct QueueNode** front, struct QueueNode** rear);
    
36. 
    
37. int Priority(char op);
    
38. 
    
39. void main()
    
40. {
    
41.         // 保存操作符的栈
    
42.         struct StackNode* top = NULL;
    
43.         // 队列中要存放的是转换后的逆波兰表达式就是后缀表达式
    
44.         struct QueueNode* front = NULL;
    
45.         struct QueueNode* rear = NULL;
    
46.         float num;
    
47.         char ch, e;
    
48.         InitQueue(&front, &rear);
    
49.         printf("请输入中缀表达式, 以回车键结束输入:\n");
    
50.         do
    
51.         {
    
52.                 scanf("%c", &ch);
    
53.                 switch ( ch )
    
54.                 {
    
55.                 case ' ': break;         // 过滤掉空格
    
56.                 // 检测到键盘缓冲区中有数字开始的字符
    
57.                 case '0':
    
58.                 case '1':
    
59.                 case '2':
    
60.                 case '3':
    
61.                 case '4':
    
62.                 case '5':
    
63.                 case '6':
    
64.                 case '7':
    
65.                 case '8':
    
66.                 case '9':
    
67.                         ungetc(ch, stdin);         // pay attention !
    
68.                         scanf("%f", &num);         // 以浮点数的格式从键盘缓冲区获得一个操作数(整数同样也可以读取)
    
69.                         EnQueue(&rear, num); break;         // 将读取到的操作数入队
    
70.                 // 碰到左括号，先放入操作符栈
    
71.                 case '(':
    
72.                         Push(&top, ch); break;
    
73.                 // 碰到有括号, 由于括号隔离了优先级, 则需要先计算左右括号之间的表达式
    
74.                 case ')':
    
75.                 case '\n':  // pay attention! 加'\n'是考虑到读取到最后的一个结束字符时栈中还有一个操作符并没有参与运算
    
76.                         // top时刻指向操作符的栈顶，当栈中存在操作符且操作符位于左右括号之间时才将栈中的操作符弹出栈，然后放入操作数队列
    
77.                         while ( top && ( e=Pop(&top), e!='(' ) )
    
78.                         {
    
79.                                 EnQueue(&rear, e);
    
80.                         }
    
81.                         break;
    
82.                 // 四则运算
    
83.                 case '+':
    
84.                 case '-':
    
85.                 case '*':
    
86.                 case '/':
    
87.                         // 判读优先级，如果当前读入的操作符优先级低于栈顶操作符优先级则说明栈顶操作符的优先级别高，将它弹出栈并入操作数队列
    
88.                         while ( Priority(ch) <= Priority(GetTop(top)) )
    
89.                         {
    
90.                                 e = Pop(&top);
    
91.                                 EnQueue(&rear, e);
    
92.                         }
    
93.                         Push(&top, ch);
    
94.                         break;
    
95.                 default:
    
96.                         printf("表达式非法!\n");
    
97.                         exit(0);
    
98.                 }
    
99.         } while( ch!='\n' );
    
100. 
     
101.         // 此时队列中存放的是转换好的逆波兰表达式（后缀表达式），有了逆波兰表达式就可以进一步的求出表达式的值了（不难的求的）^-^
     
102.         QueueTraverse(front);
     
103. 
     
104.         DestroyQueue(&front, &rear);
     
105. 
     
106.         _getch();
     
107. 
     
108. }
     
109. 
     
110. int Priority(char op)
     
111. {
     
112.         switch ( op )
     
113.         {
     
114.         case '(':
     
115.         case '#':
     
116.                 return 0;
     
117.         case '-':
     
118.         case '+':
     
119.                 return 1;
     
120.         case '*':
     
121.         case '/':
     
122.                 return 2;
     
123.         default:
     
124.                 return -1;
     
125.         }
     
126. }
     
127. 
     
128. void Push(struct StackNode** top, char ch)
     
129. {
     
130.         struct StackNode* p = (struct StackNode*)malloc(sizeof(struct StackNode));
     
131.         p->data = ch;
     
132.         p->next = *top;
     
133.         *top = p;
     
134. }
     
135. char Pop(struct StackNode** top)
     
136. {
     
137.         struct StackNode* p = *top;
     
138.         char e;
     
139.         if ( p == NULL )
     
140.         {
     
141.                 printf("下溢!\n");
     
142.                 exit(0);
     
143.         }
     
144.         e = p->data;
     
145.         *top = p->next;
     
146.         free(p);
     
147.         return e;
     
148. }
     
149. 
     
150. char GetTop(struct StackNode* top)
     
151. {
     
152.         if ( top == NULL )
     
153.         {
     
154.                 return -1;
     
155.         }
     
156.         return top->data;
     
157. }
     
158. 
     
159. void InitQueue(struct QueueNode** front, struct QueueNode** rear)
     
160. {
     
161.         struct QueueNode* p = (struct QueueNode*)malloc(sizeof(struct QueueNode));
     
162.         p->next = NULL;
     
163.         *front = *rear = p;
     
164. }
     
165. 
     
166. void EnQueue(struct QueueNode** rear, float e)
     
167. {
     
168.         if ( *rear == NULL )
     
169.         {
     
170.                 printf("队列已被销毁或者还没有被初始化, 请初始化队列!");
     
171.         }
     
172.         else
     
173.         {
     
174.                 struct QueueNode* p = (struct QueueNode*)malloc(sizeof(struct QueueNode));
     
175.                 p->data = e;
     
176.                 p->next = NULL;
     
177.                 (*rear)->next =  p;
     
178.                 *rear = p;
     
179.         }
     
180. }
     
181. 
     
182. float DeQueue(struct QueueNode* front,struct QueueNode** rear)
     
183. {
     
184.         float e;
     
185.         if ( front == NULL )
     
186.         {
     
187.                 printf("队列已被销毁或者还没有被初始化, 请初始化队列!\n\n");
     
188.         }
     
189.         else
     
190.         {
     
191.                 if ( front == *rear )
     
192.                 {
     
193.                         printf("队列为空, 无法出队!\n\n");
     
194.                 }
     
195.                 else
     
196.                 {
     
197.                         struct QueueNode* p = front->next;
     
198.                         e = p->data;
     
199.                         front->next = p->next;
     
200.                         if ( p == *rear )
     
201.                         {
     
202.                                 *rear = front;
     
203.                         }
     
204.                         free(p);
     
205.                 }
     
206.         }
     
207.         return e;
     
208. }
     
209. 
     
210. void QueueTraverse(struct QueueNode* front)
     
211. {
     
212.         struct QueueNode* p = front;
     
213.         if ( p == NULL )
     
214.         {
     
215.                 printf("队列已被销毁或者还没有被初始化, 请初始化队列!");
     
216.         }
     
217.         else
     
218.         {
     
219.                 if ( p->next == NULL )
     
220.                 {
     
221.                         printf("队列为空!");
     
222.                 }
     
223.                 else
     
224.                 {
     
225.                         printf("队列中的元素为: ");
     
226.                         while ( p->next != NULL )
     
227.                         {
     
228.                                 p = p->next;
     
229.                                 switch ( (char)p->data )
     
230.                                 {
     
231.                                 case '+':
     
232.                                 case '-':
     
233.                                 case '*':
     
234.                                 case '/':
     
235.                                         printf("%c ", (char)p->data); break;
     
236.                                 default:
     
237.                                         printf("%f ", p->data);
     
238.                                 }
     
239.                         }
     
240.                 }
     
241.         }
     
242.         printf("\n");
     
243. }
     
244. 
     
245. void DestroyQueue(struct QueueNode** front, struct QueueNode** rear)
     
246. {
     
247.         while( *front )
     
248.         {
     
249.                 *rear = (*front)->next;
     
250.                 free(*front);
     
251.                 *front = *rear;
     
252.         }
     
253. }
     

复制代码

misys

^-^

lewisyixin

非常感谢楼主

lewisyixin

非常感谢

lewisyixin

感谢分享

spy

lewisyixin 发表于 2015-12-21 23:30
非常感谢

很高心能帮助到你^_^