[已解决]中缀表达式转后缀表达式

夏季的春秋

中缀表达式转后缀表达式，在编译器上运行是好的，但是提交到oj上就一直是输出超限，想知道怎么解决？
下面上代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define STACK_INIT_SIZE 20
   
5. #define STACKINCREMENT 10
   
6. 
   
7. typedef char ElemType;
   
8. typedef struct
   
9. {
   
10.     ElemType *base;
    
11.     ElemType *top;
    
12.     int stacksize;
    
13. }sqstack;
    
14. 
    
15. void initstack(sqstack *s)
    
16. {
    
17.     s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    
18.     if(!s->base)
    
19.     {
    
20.         exit(0);
    
21.     }
    
22.     s->top=s->base;
    
23.     s->stacksize=STACK_INIT_SIZE;
    
24. }
    
25. 
    
26. void push(sqstack *s,char e)
    
27. {
    
28.     if(s->top-s->base>=s->stacksize)
    
29.     {
    
30.         s->base=(ElemType *)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));
    
31.         if(!s->base)
    
32.         {
    
33.             exit(0);
    
34.         }
    
35.         s->top=s->base+s->stacksize;
    
36.         s->stacksize=s->stacksize+STACKINCREMENT;
    
37.     }
    
38. 
    
39.     *(s->top)=e;
    
40.     s->top++;
    
41. }
    
42. 
    
43. void pop(sqstack *s,char *e)
    
44. {
    
45.     if(s->top==s->base)
    
46.     {
    
47.         return;
    
48.     }
    
49. 
    
50.     *e=*--(s->top);
    
51. }
    
52. 
    
53. int stacklen(sqstack s)
    
54. {
    
55.     return (s.top-s.base);
    
56. }
    
57. 
    
58. int main(void)
    
59. {
    
60.     sqstack s;
    
61.     char c,e;
    
62. 
    
63.     initstack(&s);
    
64. 
    
65.     while((scanf("%c",&c))!=EOF)
    
66.     {
    
67.         while((c>='A'&&c<='Z')||(c>='a'&&c<='z'))
    
68.         {
    
69.             printf("%c",c);
    
70.             scanf("%c",&c);
    
71.         }
    
72. 
    
73.         if(')'==c)
    
74.         {
    
75.             pop(&s,&e);
    
76.             while('('!=e)
    
77.             {
    
78.                 printf("%c",e);
    
79.                 pop(&s,&e);
    
80.             }
    
81.         }
    
82. 
    
83.         else if('+'==c||'-'==c)
    
84.         {
    
85.             if(!stacklen(s))
    
86.             {
    
87.                 push(&s,c);
    
88.             }
    
89.             else
    
90.             {
    
91.                 do
    
92.                 {
    
93.                     pop(&s,&e);
    
94.                     if('('==e)
    
95.                     {
    
96.                         push(&s,e);
    
97.                     }
    
98.                     else
    
99.                     {
    
100.                         printf("%c",e);
     
101.                     }
     
102.                 }while(stacklen(s)&&'('!=e);
     
103.                 push(&s,c);
     
104.             }
     
105.         }
     
106.         else if(c=='*'||c=='/')
     
107.         {
     
108.             pop(&s,&e);
     
109.             if(e=='*'||e=='/')
     
110.             {
     
111.                 printf("%c",e);
     
112.             }
     
113.             else
     
114.             {
     
115.                 push(&s,e);
     
116.             }
     
117.             push(&s,c);
     
118.         }
     
119.         else if(c=='(')
     
120.         {
     
121.             push(&s,c);
     
122.         }
     
123.         else if('\n'==c)
     
124.         {
     
125.             break;
     
126.         }
     
127.         else
     
128.         {
     
129.             return -1;
     
130.         }
     
131.     }
     
132. 
     
133.     while(stacklen(s))
     
134.     {
     
135.         pop(&s,&e);
     
136.         printf("%c",e);
     
137.     }
     
138. 
     
139.     return 0;
     
140. }
     

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-6-7 12:18:39

看起来这个程序用于将中缀表达式转换为后缀表达式。如果你在提交到在线编程环境（Online Judge）时遇到了输出超限的问题，这可能是由于程序输出了比预期更多的数据，或者程序陷入了无限循环。

一种可能的原因是，对于每一个字符，如果它不是字母，'+'，'-'，'*'，'/'，'('，')'，或者'\n'，程序会返回-1并结束，这可能是在处理空格或者其他不在预期中的字符时出现问题。如果输入中包含这些字符，程序可能会意外结束，或者在处理之前的循环中陷入无限循环。

另一种可能的原因是，这个程序没有考虑到优先级更高的运算符在优先级较低的运算符之前的情况。例如，对于表达式 a+b*c ，这个程序会生成后缀表达式 abc*+ ，这是正确的。但是对于表达式 a*b+c ，这个程序会生成 ab*c+ ，这是错误的，正确的后缀表达式应该是 ab*c+ 。这是因为在处理'+'时，程序应该将栈中所有的运算符都弹出，直到遇到了'('或者栈为空。

为了解决这些问题，你可能需要做以下修改：

1. 添加一个条件来处理空格字符，忽略它们而不是结束程序。

2. 在处理运算符的优先级时，应该考虑到所有的情况，不仅仅是当前运算符比栈顶运算符的优先级更高的情况。你可能需要写一个函数来比较两个运算符的优先级，然后在处理运算符时使用这个函数。

跳转到最佳答案楼层

isdkz

看起来这个程序用于将中缀表达式转换为后缀表达式。如果你在提交到在线编程环境（Online Judge）时遇到了输出超限的问题，这可能是由于程序输出了比预期更多的数据，或者程序陷入了无限循环。

一种可能的原因是，对于每一个字符，如果它不是字母，'+'，'-'，'*'，'/'，'('，')'，或者'\n'，程序会返回-1并结束，这可能是在处理空格或者其他不在预期中的字符时出现问题。如果输入中包含这些字符，程序可能会意外结束，或者在处理之前的循环中陷入无限循环。

另一种可能的原因是，这个程序没有考虑到优先级更高的运算符在优先级较低的运算符之前的情况。例如，对于表达式 a+b*c ，这个程序会生成后缀表达式 abc*+ ，这是正确的。但是对于表达式 a*b+c ，这个程序会生成 ab*c+ ，这是错误的，正确的后缀表达式应该是 ab*c+ 。这是因为在处理'+'时，程序应该将栈中所有的运算符都弹出，直到遇到了'('或者栈为空。

为了解决这些问题，你可能需要做以下修改：

1. 添加一个条件来处理空格字符，忽略它们而不是结束程序。

2. 在处理运算符的优先级时，应该考虑到所有的情况，不仅仅是当前运算符比栈顶运算符的优先级更高的情况。你可能需要写一个函数来比较两个运算符的优先级，然后在处理运算符时使用这个函数。

夏季的春秋

isdkz 发表于 2023-6-7 12:22
看起来这个程序用于将中缀表达式转换为后缀表达式。如果你在提交到在线编程环境（Online Judge）时遇到了输 ...

我在输入乘和除加了个判断栈是否为空，现在是82%，想问还差18%怎么改

isdkz

夏季的春秋 发表于 2023-6-7 16:54
我在输入乘和除加了个判断栈是否为空，现在是82%，想问还差18%怎么改

如果你的程序已经通过了82%的测试用例，那么你已经成功地处理了大多数情况。下面是一些可能影响程序正确性的问题，可以帮助你找出剩下的问题：

1. 优先级判断: 在处理'+'和'-'运算符时，你的程序会将栈中所有的运算符都弹出，直到遇到'('。这意味着，如果输入是 a*b+c ，程序会生成 ab*c+ ，这是正确的。但是，如果输入是 a+b*c ，程序也会生成 abc*+ ，这是错误的，正确的后缀表达式应该是 ab+c* 。这是因为'+'的优先级低于'*'。在这个例子中，你需要修改你的程序，使其只在当前运算符的优先级高于或等于栈顶运算符的优先级时，才将栈顶运算符弹出。

2. 非法字符: 确保你的程序能够正确处理所有非法字符。你的程序应该能够处理所有可能出现的字符，而不只是'A'到'Z'，'a'到'z'，'+'，'-'，'*'，'/'，'('，')'和'\n'。

3. 空格和换行符: 你的程序应该能够忽略输入中的空格和换行符。在当前的程序中，如果输入中包含空格，程序可能会提前结束。

4. 错误的输入: 确保你的程序能够处理错误的输入。例如，如果输入的表达式中包含不匹配的括号，或者包含非法的字符，你的程序应该能够检测到这些错误。

如果这些建议不能帮助你找出问题，你可能需要更详细地检查你的程序，或者用更多的测试用例来测试它。

夏季的春秋

isdkz 发表于 2023-6-7 16:56
如果你的程序已经通过了82%的测试用例，那么你已经成功地处理了大多数情况。下面是一些可能影响程序正确 ...

这第一个优先级判断a+b*c的a+b应该加括号把，不然不是后面的那个后缀表达式

夏季的春秋

终于想出来了，上代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define STACK_INIT_SIZE 20
   
5. #define STACKINCREMENT 10
   
6. 
   
7. typedef char ElemType;
   
8. typedef struct
   
9. {
   
10.     ElemType *base;
    
11.     ElemType *top;
    
12.     int stacksize;
    
13. }sqstack;
    
14. 
    
15. void initstack(sqstack *s)
    
16. {
    
17.     s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    
18.     if(!s->base)
    
19.     {
    
20.         exit(0);
    
21.     }
    
22.     s->top=s->base;
    
23.     s->stacksize=STACK_INIT_SIZE;
    
24. }
    
25. 
    
26. void push(sqstack *s,char e)
    
27. {
    
28.     if(s->top-s->base>=s->stacksize)
    
29.     {
    
30.         s->base=(ElemType *)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));
    
31.         if(!s->base)
    
32.         {
    
33.             exit(0);
    
34.         }
    
35.         s->top=s->base+s->stacksize;
    
36.         s->stacksize=s->stacksize+STACKINCREMENT;
    
37.     }
    
38. 
    
39.     *(s->top)=e;
    
40.     s->top++;
    
41. }
    
42. 
    
43. void pop(sqstack *s,char *e)
    
44. {
    
45.     if(s->top==s->base)
    
46.     {
    
47.         return;
    
48.     }
    
49. 
    
50.     *e=*--(s->top);
    
51. }
    
52. 
    
53. int stacklen(sqstack s)
    
54. {
    
55.     return (s.top-s.base);
    
56. }
    
57. 
    
58. int value (char c)
    
59. {
    
60.     if(c=='+'||c=='-')
    
61.     {
    
62.         return 1;
    
63.     }
    
64.     else if(c=='*'||c=='/')
    
65.     {
    
66.         return 2;
    
67.     }
    
68.     else if(c=='('||c==')')
    
69.     {
    
70.         return 3;
    
71.     }
    
72. }
    
73. 
    
74. int main(void)
    
75. {
    
76.     sqstack s;
    
77.     char c,e;
    
78. 
    
79.     initstack(&s);
    
80. 
    
81.     while((scanf("%c",&c))!=EOF)
    
82.     {
    
83.         if((c>='A'&&c<='Z')||(c>='a'&&c<='z'))
    
84.         {
    
85.             printf("%c",c);
    
86.         }
    
87. 
    
88.         else
    
89.         {
    
90.             if(c=='(')
    
91.                 {
    
92.                     push(&s,c);
    
93.                 }
    
94.             else if(')'==c)
    
95.             {
    
96.                 pop(&s,&e);
    
97.                 while(('('!=e)&&(stacklen(s)!=0))
    
98.                         {
    
99.                             printf("%c",e);
    
100.                             pop(&s,&e);
     
101.                         }
     
102.             }
     
103.             else if('+'==c||'-'==c)
     
104.                 {
     
105.                     if(!stacklen(s))
     
106.                     {
     
107.                         push(&s,c);
     
108.                     }
     
109.                     else
     
110.                     {
     
111.                         do
     
112.                             {
     
113.                                 pop(&s,&e);
     
114.                                 if('('==e)
     
115.                                     {
     
116.                                         push(&s,e);
     
117.                                     }
     
118.                                 else
     
119.                                     {
     
120.                                         printf("%c",e);
     
121.                                     }
     
122.                             }while(stacklen(s)&&'('!=e);
     
123.                         push(&s,c);
     
124.                      }
     
125.                   }
     
126.             else if(c=='*'||c=='/')
     
127.                 {
     
128.                      if(!stacklen(s))
     
129.                         {
     
130.                             push(&s,c);
     
131.                         }
     
132.                      else if(c=='*'||c=='/')
     
133.                         {
     
134.                             pop(&s,&e);
     
135.                             if('*'==e||'/'==e)
     
136.                             {
     
137.                                 printf("%c",e);
     
138.                             }
     
139.                             else
     
140.                             {
     
141.                                 push(&s,e);
     
142.                             }
     
143.                             push(&s,c);
     
144.                         }
     
145.                 }
     
146. 
     
147.             else if('\n'==c)
     
148.                 {
     
149.                     break;
     
150.                 }
     
151.             else
     
152.                 {
     
153.                     exit(0);
     
154.                 }
     
155.         }
     
156.     }
     
157. 
     
158.     while(stacklen(s))
     
159.     {
     
160.         pop(&s,&e);
     
161.         printf("%c",e);
     
162.     }
     
163. 
     
164.     return 0;
     
165. }

复制代码