RPN计算

pwnmelife

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <ctype.h>
   
4. 
   
5. #define STACK_INIT_SIZE 20
   
6. #define STACKINCREAMENT 10
   
7. #define MAXBUFFER 10
   
8. 
   
9. typedef double ElementType;
   
10. 
    
11. typedef struct {
    
12.         ElementType* base;
    
13.         ElementType* top;
    
14.         int stackSize;
    
15. }sqStack;
    
16. 
    
17. void InitStack(sqStack* s);
    
18. bool StackEmpty(sqStack* s);
    
19. void Push(sqStack* s, double e);
    
20. void Pop(sqStack* s, double* e);
    
21. 
    
22. int main()
    
23. {
    
24.         sqStack* s = (sqStack*)malloc(sizeof(sqStack*));
    
25.         InitStack(s);
    
26.         char buffer[MAXBUFFER];
    
27.         char c = '0';
    
28.         double left, right, result;
    
29.         printf("Please input a string of RPN expression, the # character ends up with the input\n");
    
30.         while (true) {
    
31.                 int i = 0;
    
32.                 while (1) {
    
33.                         scanf("%c", &c);
    
34.                         if (isdigit(c)||c == '.') {
    
35.                                 buffer[i++] = c;
    
36.                         }
    
37.                         else if(c == ' ' && i != 0){
    
38.                                 buffer[i] = '\0';
    
39.                                 double value = atof(buffer);
    
40.                                 Push(s, value);
    
41.                                 break;
    
42.                         }
    
43.                         else {
    
44.                                 break;
    
45.                         }
    
46.                 }
    
47.                 switch (c) {
    
48.                 case '+':
    
49.                         Pop(s, &left);
    
50.                         Pop(s, &right);
    
51.                         Push(s, left+right);
    
52.                         break;
    
53.                 case '-':
    
54.                         Pop(s, &right);
    
55.                         Pop(s, &left);
    
56.                         Push(s, left - right);
    
57.                         break;
    
58.                 case '*':
    
59.                         Pop(s, &right);
    
60.                         Pop(s, &left);
    
61.                         Push(s, left * right);
    
62.                         break;
    
63.                 case '/':
    
64.                         Pop(s, &right);
    
65.                         Pop(s, &left);
    
66.                         if (right == 0.0) {
    
67.                                 printf("The divisor is not equal to zero\n");
    
68.                         }
    
69.                         Push(s, left/right);
    
70.                         break;
    
71.                 default :
    
72.                         break;
    
73.                 }
    
74.                 if (c == '#') {
    
75.                         break;
    
76.                 }
    
77.         }
    
78.         Pop(s, &result);
    
79.         printf("The final result is %lf\n", result);
    
80.         return 0;
    
81. }
    
82. void InitStack(sqStack* s) {
    
83.         s->top = s->base = (ElementType*)malloc(STACK_INIT_SIZE * sizeof(double));
    
84.         if (!s->top) {
    
85.                 exit(0);
    
86.         }
    
87.         s->stackSize = STACK_INIT_SIZE;
    
88. }
    
89. bool StackEmpty(sqStack* s) {
    
90.         if (s->top == s->base) {
    
91.                 return true;
    
92.         }
    
93.         else {
    
94.                 return false;
    
95.         }
    
96. }
    
97. void Push(sqStack* s, double e) {
    
98.         if (s->top - s->base >= s->stackSize) {
    
99.                 s->base = (ElementType*)realloc(s->base, s->stackSize + STACKINCREAMENT);
    
100.                 if (!s->base) {
     
101.                         exit(0);
     
102.                 }
     
103.                 s->stackSize = s->stackSize + STACKINCREAMENT;       
     
104.         }
     
105.         *(s->top) = e;
     
106.         s->top++;
     
107. 
     
108. }
     
109. void Pop(sqStack* s, double* e) {
     
110.         if (StackEmpty(s)) {
     
111.                 return;
     
112.         }
     
113.         *e = *--(s->top);
     
114. }

复制代码