java中缀表达式转后缀表达式为何会提示下标越界?

public void actionPerformed(ActionEvent e)
{
String s = new String(); //接收用户输入的中缀表达式
char [] str = new char[255]; //存放用户输入的中缀表达式(字符数组形式)
char [] str2 = new char[255]; //保存将用户输入的中缀表达式转化的后缀表达式
Stack st = new Stack();
char temp;
s = tf.getText();
str = s.toCharArray();
int i;
int n = 0;
int len = s.length();

for (i=0; i {
while (str[i] >= '0' && str[i] <= '9')
{
str2[n++] = str[i++];

if (str[i] < '0' || str[i] > '9')
{
str2[n++] = ' ';
break;
}
}
if (str[i] == '(')
{
st.push(str[i]);
}
else if (str[i] == ')')
{
temp = (char)st.pop();

while ('(' != temp)
{
str2[n++] = temp;
str2[n++] = ' ';
temp = (char)st.pop();
}
}
else if (str[i] == '+' || str[i] == '-')
{
if (st.empty())
{
st.push(str[i]);
}
else
{
do
{
temp = (char)st.pop();

if ('(' == temp)
{
st.push(temp);
}
else
{
str2[n++] = temp;
str2[n++] = ' ';
}
}while (!st.empty() && temp != '(');

st.push(str[i]);
}
}
else if (str[i] == '*' || str[i] == '/')
{
if (st.empty())
{
st.push(str[i]);
}
else
{
do
{
temp = (char)st.pop();

if ('(' == temp || '+' == temp || '-' == temp)
{
st.push(temp);
break;
}
else
{
str2[n++] = temp;
str2[n++] = ' ';
}
}while (!st.empty());

st.push(str[i]);
}
}
else if (i == len)
{
break;
}
else
{
System.out.println("出错");
System.exit(-1);
}
}

while (!st.empty())
{
temp = (char)st.pop();
str2[n++] = temp;
str2[n++] = ' ';
}

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
Java中缀表达式转后缀表达式
我们把平时所用的标准四则运算表达式,即“9+(3-1)*3+10/2”叫做中缀表达式。因为所有的运算符号都在两数字的中间,现在我们的问题就是中缀到后缀的转化。 【5+4*6/2+3+(4*5)/5】->【5 4 6 * 2 / + 3 + 4 5 *5 / +】思路 首先定义两个集合,一个用于存储最后的结果,一个用于存储转换过程中的操作符 从左到右遍历中缀表达式的每个数字和符号 1
Java -- 中缀表达式转后缀表达式
中缀表达式 转 后缀表达式 举例示意图: 全部代码: package ShunXuZhan; import java.util.Arrays; class Constant { /** * 表示加法 */ public static final int OPERATORS_PRIO_PLUS_IN = 4; //栈内加法 public s...
JAVA中缀表达式转后缀表达式
基于前述文章,将代码改写,把中缀表达式转为后缀表达式package com.后缀表达式;import java.util.ArrayList; import java.util.Stack;public class 生成后缀表达式 { public static void main(String[] args) { System.out.println(generate("85
中缀表达式转后缀表达式--Java
利用自己用数组实现的ArrayStack(与常规的栈功能基本一致)实现将中缀表达式变成后缀表达式。这个题目应该都有见过,自己也是看了些资料,加上自己的理解实现的,这里记录一下,给自己以后看。如果觉得可以,也分享一下。 例如:     a + b * c + ( d * e + f ) * g --> a b c * + d e * f + g * +;     a + b - a * ( (
java 中缀表达式转后缀表达式
java 中缀表达式转后缀表达式lz在网上百度啦理论知识然后自己实现了代码,有些网友的代码实在。。。。好吧,我们开始1 基本概念在计算机中表达式有三种,前缀表达式(波兰式),中缀表达式,后缀表达式(逆波兰式)。如表达式:a+b*(c-d)-e/f前缀表达式:-+a*b-cd/ef中缀表达式:a+b*(c-d)-e/f后缀表达式:abcd-*+ef/-1.1 特点与利弊中缀表达式的括号必不可少,它的优
中缀表达式算法实现&中缀表达式转后缀表达式
中缀表达式,即运算符在操作数中间。 计算中缀表达式时,逐个扫描表达式。 扫描时存入两个栈,操作数栈,和运算符栈。 例如   3*2^(4+2*2-1*3)-5  扫描表达式。 操作数栈以 栈$表示,运算符栈以 栈¥表示。 扫描开始: 栈$进3  ,栈¥进*  , 栈$进2 ,栈¥进^ ,栈¥进(,栈$进4 , 栈¥进+ , 栈 $进2 , 栈¥进*   接下来由于 - 减号运算符优
java实现中缀表达式转后缀表达式
public class StackTest { public static void main(String[] args){ String s = &quot;5+4*6/2+3+(4*5)/5&quot;;//546*2/+3+45*5/+ // String s = &quot;2*(9+6/3-5)+4&quot;;//2963/+5-*4+ System.out.pri...
Java 中缀表达式转换为后缀表达式
计算机进行运算并不是按照中缀表达式来进行运算的,而是按照后缀表达式。 如何将中缀表达式转换为前缀、后缀表达式。例如式子:1 + 2 * (9 - (6-4) *2 + 5),按照运算顺序将每一步都加上括号 (1 + (2 * (((9 - ((6-4) *2)) + 5)))),再将运算符号移到括号的前面和后面,+(1 *(2 +((-(9 *(-(64) 2))  5))))  ,(1 (2 
后缀表达式求值及中缀表达式转后缀表达式
关于后缀表达式的计算机求值以及中缀表达式转后缀表达式的分析请看我的另一篇博客——中缀表达式转前、后缀表达式及其求值后缀表达式求值#include<iostream> #include<iomanip> #include<cstdlib> #include<cctype> #include<cmath> using namespace std; #define MaxSize 100
中缀表达式转后缀表达式
利用之前的栈的顺序存储和栈的链式存储,写了一个就近匹配和中缀表达式转后缀表达式,
中缀表达式转换为后缀表达式
问题:给出一个表达式,含有括号,将其转化成后缀表达式输出 算法:用栈维护将要输出的运算符(operator) 读入一个token 1)如果是数,直接输出 2)如果是运算符(不含括号),比较其与栈顶元素优先级 若栈顶元素同级或更高级,则将其出栈并输出,直到栈为空或者栈顶运算符级别更低 3)如果是左括号'(', 则将其入栈 4)如果是右括号')', 则将栈顶元素依次出栈并输出,直到有匹配
【小结】中缀表达式转后缀表达式
这两天学习数据结构中表达式计算的算法,现在小结一下 中缀表达式转后缀表达式(RPN) 1. 建立一个optr栈用来存放操作符 2. 从左到右遍历整个表达式 2.1 若遇到操作数,则将其添加在RPN末尾 2.2 若遇到操作符 2.2.1 如果optr栈为空,操作符入optr栈 2.2.2 如果栈顶操作符优先级小于当前操作符,则当前操作符入栈 2.2.3 如果栈顶操作符优先级大
1003. 中缀表达式转后缀表达式
Time Limit: 1sec Memory Limit:256MB Description 将中缀表达式(infix expression)转换为后缀表达式(postfix expression)。假设中缀表达式中的操作数均以单个英文字母表示,且其中只包含双目算术操作符+,-,*,/和%。 Input 表示中缀表达式的一个字符串(其中只包含操作数和操作符,不包含任何其他字符) O
C++中缀表达式转后缀表达式
#include&amp;lt;iostream&amp;gt; #include&amp;lt;stack&amp;gt; #include&amp;lt;string&amp;gt; using namespace std; //定义优先级 string priority = &quot;#(+-*/)&quot;; int locate(char c,string str) { int locate = str.find(c); if (locat...
中缀表达式转后缀表达式(逆波兰)
一、中缀表达式转后缀表达式中缀表达式就是普通的表达式。如:9+(3-1)*3+10/2 后缀表达式是一种不需要括号的表示法,又叫逆波兰表达式。上面的式子用后缀法表示:9 3 1 - 3 * + 10 2 / +那么如何转化成后缀表达式?思路:从左往右遍历: 1. 如果是数字则直接输出 2. 如果是符号则入栈,但要通过以下判断 若该符号c是右括号或者c的优先级≤栈顶符号,则栈中元素依次出栈输出,
中缀表达式转化为后缀表达式
[code=c]#includern#includern#includern#define STACK_INIT_SIZE 20rn#define STACKINCREMENT 10rnrn#define OK 1rn#define ERROR 0rntypedef char ElemType;rntypedef structrnrn ElemType *base;rn ElemType *top;rn int stacksize;rnSqStack;rn rnrnint InitStack(SqStack *s)rnrn s->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));rn if(!s->base)rn exit(0);rn s->top=s->base;rn s->stacksize=STACK_INIT_SIZE;rn return OK;rnrnint Push(SqStack *s,ElemType e)rnrn if(s->top-s->base>=s->stacksize)rn rn s->base=(ElemType *)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));rn if(!s->base)rn exit(0);rnrn rn *(s->top)=e;rn s->top++;rn return OK;rnrnint Pop(SqStack *s,ElemType *e)rnrn if(s->top==s->base)rn rn return ERROR;rn rn *e=*--(s->base);rn return OK;rnrnint Stacklen(SqStack s)rnrn return (s.top-s.base);rnrnint InitStack(SqStack *s); rnint Push(SqStack *s,ElemType e); rnint Pop(SqStack *s,ElemType *e); rnint StackLen(SqStack s); rnint main()rnrn SqStack s;rn char c,e;rn InitStack(&s);rn printf("请输入中缀表达式\n");rn scanf("%c",&c);rn while(c!='#')rn rn while(c>='0'&&c<='9')rn rn printf("%c",c);rn scanf("%c",&c);rn if(c<'0'||c>'9')rn rn printf(" ");rn rn rn if(')'==c)rn rn Pop(&s,&e);rn while('('!=e)rn rn printf("%c",e);rn Pop(&s,&e);rn rn rn else if('+'==c||'-'==c)rn rn if(!Stacklen(s))rn rn Push(&s,c);rn rn elsern rn dorn rn Pop(&s,&e);rn if('('==e)rn rn Push(&s,e);rn rn elsern rn printf("%c",e);rn rn while(Stacklen(s)&&'('!=e);rn Push(&s,c);rn rn rn else if('*'==c||'/'==c||'('==c)rn rn Push(&s,c);rn rn else if('#'==c)rn rn break;rn rn elsern rn printf("用户输入失败\n");rn return ERROR;rn rn scanf("%c",&c);rn rn while(Stacklen(s))rn rn Pop(&s,&e);rn printf("%c",e);rn rn return 0;rn[/code]rn这段程序哪里出错了,调试没有错,为什么运行的时候会出来一大堆警告呢?
【MR.Question】中缀表达式转后缀表达式
如题,谁有能算多位数(包括带小数点数)的中缀表达式转后缀表达式还带计算的代码拿来看看?(JAVA的)
中缀表达式转换到后缀表达式
按照以下方法进行转换,为什么结果不一样,当运算符的优先级一样时,如*和/时,是压栈还是出栈呢,请高手能够予以解答,谢谢rn转换算法:rn1)检查输入的下一元素。rn2)假如是个操作数,输出。rn3)假如是个开括号,将其压栈。rn4)假如是个运算符,则rn i) 假如栈为空,将此运算符压栈。rn ii) 假如栈顶是开括号,将此运算符压栈。rn iii) 假如此运算符比栈顶运算符优先级高,将此运算符压入栈中。rn iv) 否则栈顶运算符出栈并输出,重复步骤4。rn5)假如是个闭括号,栈中运算符逐个出栈并输出,直到遇到开括号。开括号出栈并丢弃。rn6)假如输入还未完毕,跳转到步骤1。rn7)假如输入完毕,栈中剩余的所有操作符出栈并输出它们。rn以对下中缀表达式2*(x+y)/(1-x)转换成后缀表达式应该是什么?
中缀表达式转后缀表达式(c++)
初始化两个栈:运算符栈s1和储存中间结果的栈s2; 从左至右扫描中缀表达式; 遇到操作数时,将其压s2; 遇到运算符时,比较其与s1栈顶运算符的优先级: 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈; 否则,若优先级比栈顶运算符的高,也将运算符压入s1 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4-1)与s1中新的栈顶运算符相比较; 遇到括号时:...
表达式树---中缀表达式转后缀表达式
** 题目描述 ** 给定中缀表达式(只限 + - * / () 和 小写字母),求其后缀表达式。 分析 关于中缀表达式的处理,有两种方法,一是用双栈处理,二是先建立一颗表达式树,再对其进行遍历处理。 本文讲述后者的方法 前序遍历 –&amp;amp;amp;amp;gt; 前缀表达式(波兰式) 中序遍历 –&amp;amp;amp;amp;gt; 中缀表达式 后序遍历 –&amp;amp;amp;amp;gt; 后缀表达式(逆波兰式) ...
中缀表达式转后缀表达式的方法
平时所用的标准四则运算表达式,即“9+(3-1)*3+10/2"叫做中缀表达式。因为所有的运算符号都在两数字的中间。将该中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1-3*+ 10 2/+”,如何做到呢?规则如下:1.遇到操作数:直接输出(添加到后缀表达式中) 2.栈为空时,遇到运算符,直接入栈 3.遇到左括号:将其入栈 4.遇到右括号:执行出栈操作,并将出栈的元素输出
后缀表达式转中缀表达式
这个专题很迷,因为这种东西很少使用,一般都是中缀转后缀(容易计算),但是有一些bt的题目总是喜欢这样倒着出题,所以适当的了解还是有必要的。题目描述给出按后缀表示法输入的一个算术表达式,表达式中只有26个大写英文字母和加减乘除四个运算符号,表达式的长度<=50,表达式以#号结束。请你编程求出它的等价中缀表达式。输入输出格式输入格式: 输入文件只有一行,就是后缀表达式。输出格式: 输出文件只有一行,就是
C++ - 中缀表达式转后缀表达式
中缀表达式转后缀表达式遵循以下原则: 1.遇到操作数,直接输出; 2.栈为空时,遇到运算符,入栈; 3.遇到左括号,将其入栈; 4.遇到右括号,执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出; 5.遇到其他运算符’+”-”*”/’时,弹出所有优先级大于或等于该运算符的栈顶元素,然后将该运算符入栈...
C++ 中缀表达式转后缀表达式
一、思路:和中缀表达式的计算类似,只不过不用计算,把表达式输出即可       1.用字符数组存储整行输入的中缀表达式;       2.接着从字符数组的0位置开始判断字符,如果是数字,那就要判断后面是否是数字,如果是就不断扫描组成一个整数         (暂不考虑负数和小数),最终组成一个整数,然后输出这个数(因为不用计算,所以直接输出即可);       3.如果是左括号,直接进符号...
后缀表达式转换为中缀表达式
是一道作业题,在OJ平台上提交,有效率要求。OJ平台会进行十次测试。我的第一个版本是C++写的,主要用string类型,只能通过七次,同学都说string类型可能效率不够高。第二个版本用C写,我自己在VS2015上运行没问题,但是到OJ平台上却一次也通不过。要知道前三次都是很简单情形,只要程序正确就应该没错,可能是一些内存访问操作在平台上被判为非法。求前辈们帮忙改一下,指出一下问题或者效率改进方案。在这个题上耗了两天多了。初学者。rn对了有同学说C用realloc好像通不过,那不用realloc该怎么改呢?rn谢谢!rnrn题目:中缀表达式与后缀表达式rnrnDescriptionrnrn将一个后缀表达式转换为一个中缀表达式。rnInput Descriptionrnrn一个合法的后缀表达式。它由一串连续的操作数与运算符的序列构成。操作数用英文小写字母表示,且运算符只有五种,每个运算符只有一种符号表示。相邻的操作数与运算符之间均没有任何分隔符。rnrn输入中会出现的运算符rn运算符 符号 优先级 备注rn阶乘 ! 高 一元运算符rn乘号 * 中 rn除号 / 中 rn加号 + 低 rn减号 - 低 rnOutput Descriptionrnrn一个中缀表达式,它由一串连续的操作数与操作符的序列构成,它与输入的后缀表达式表达同一个算术表达式。由于中缀表达式会遇到运算符的优先级问题,你需要适当地插入左括号和右括号来调整运算的优先级。输出中允许出现的运算符有七种,每个运算符只有一种符号表示。除了操作数和运算符不允许输出任何空格、换行等分隔符。rnrn输出中允许出现的运算符rn运算符 符号 优先级 备注rn左括号 ( 最高 rn右括号 ) 最高 与左括号搭配使用rn阶乘 ! 高 一元运算符rn乘号 * 中 rn除号 / 中 rn加号 + 低 rn减号 - 低 rn为了减少括号的数量以及保证输出唯一性,我们要求你尽可能地避免括号的使用,除非这样做将改变表达式中某些运算的发生次序。特别要注意,左右操作数的顺序是不可改变的,我们认为 a + b 和 b + a 是不同的表达式。对于满足 结合律的运算,运算发生次序不变的情况下应该省略括号,否则不能省略括号:我们认为 (a + b) + c 与 a + b + c 是同样的表达式,而 a + (b + c) 与 a + b + c是不同的。例如: (a + b) + (c + d) 中,如果删除第一对括号,运算结果和运算次序都没有变化;如果删除第二对括号,运算结果没有变化,但是 a + b 会首先与 c 相加,导致运算次序变化。所以这种情况下应该输出 a + b + (c + d)。rnrnInput Samplernrnab+cde*f*+fd+qp-!*-+rnrnOutput Samplernrna+b+(c+d*e*f-(f+d)*(q-p)!)rnHintrnrn你可以将生成的中缀表达式转换回后缀表达式,以验证中缀表达式的正确性。 请你自行想办法验证它是否是括号最少而不影响运算次序的结果。rnrn我的两个版本:rnc++版本:rn#includern#includern//#define STACK_SIZE 7000//栈的大小,可以容纳1000个表达式 使用宏定义全局变量,方便修改rn//#define StringNode_SIZE 7000//StringNode 类对象中的字符串数组大小rnusing namespace std;rn// 定义栈的数据结构。rnint JudgePriority(char c);//向前引用声明 判断运算符c的优先级rnint Length;//全局变量rnclass StringNode //Stringnode节点,存储每一个表达式及其优先级rnprivate:rn string STring;rn int priority;//优先级rnpublic:rn StringNode() rn // STring = "\0";rn priority = 10;//默认初始状态rn rn StringNode(char Char1) //单个字符建立对象,只有字母是需要这种情况rn STring = Char1;rn priority = 4;//设定字母优先级为4,是最高,括号4与单个字母等价,阶乘3rn rn StringNode(string ExpressionString, int Priority1) //表达式字符串建立对象rn // STring.at(0) = '\0';//防止栈访问出错rn STring = ExpressionString;rn priority = Priority1;rn rn friend StringNode Compose(StringNode &SN1, char Operator, StringNode &SN2) //由两个表达式和一个运算符组成一个新的表达式 加括号也是在这一步rn AutoAddBrackets(SN1, Operator, SN2);//如果需要的话自动给SN1,2加括号rn return StringNode(SN1.STring + Operator + SN2.STring, JudgePriority(Operator));rn rn friend StringNode Compose(StringNode &SN1, char Operator) //由一个表达式和一个单目运算符(!)组成一个新的表达式 加括号也是在这一步rn AutoAddBrackets(SN1, Operator);//如果需要的话自动给SN1加括号rn SN1.STring += Operator;rn return StringNode(SN1.STring, 3);//这个运算符的优先级就给了合成的表达式(必然是阶乘的3)rn rn friend void AutoAddBrackets(StringNode &SN1, char Operator, StringNode &SN2) //使用引用!为了修改实参rn if (SN1.priority >= JudgePriority(Operator) && JudgePriority(Operator) >= SN2.priority) rn SN2.AddBrackets();return;rn rn else if (SN1.priority == 1 && (Operator=='*'|| Operator == '/') && SN2.priority >= 3) rn SN1.AddBrackets();return;rn rn else if (SN1.priority == 1 && (Operator == '*' || Operator == '/') && SN2.priority <= 2) rn SN1.AddBrackets();SN2.AddBrackets();return;rn rn else//两边都不加括号情况,最多rn return;rn rn friend void AutoAddBrackets(StringNode &SN1, char Operator) rn if (SN1.priority<3 ) //如果是!rn SN1.AddBrackets();rn rn rn void AddBrackets() rn STring = STring.insert(0,1,'(') + ")";rn priority = 4;//加括号以后,优先级变得和数字一样高rn rn void PrintString() //输出本对象中的STring字符串rn cout << STring;rn rn;rnclass Stack rnprivate:rn StringNode *Buffer; //保存栈中的数据,指向栈首rn int top; //栈的深度rnpublic:rn Stack(int Len) rn Buffer = new StringNode[Len];//这个数组只能用Buffer来指示,不能起一个数组名rn top = 0;//初始没有元素,top指代第零个rn rn void push(StringNode val) //压栈操作 rn Buffer[top++] = val;rn rn StringNode pop() //出栈操作 rn top--;//由于top总是指向下一个还没有值的位置,因此先要把top后退一位rn return Buffer[top];rn rn void PrintStack() //最终的输出rn Buffer[0].PrintString();rn rn;rnbool IsCharacter(char c) //判字母函数rn return c >= 'a'&&c <= 'z';rnrnbool IsBiOperator(char c) //判二元运算符rn return c == '+' || c == '*' || c == '/' || c == '-';rnrnbool IsSingleOperator(char c) //判一元运算符(!)rn return c == '!';rnrnint JudgePriority(char c) //返回操作符号的优先级rn if (c == '+' || c == '-')//if判断必须加括号,return可以不用rn return 1;rn else if (c == '*' || c == '/')rn return 2;rn else if (c == '!')rn return 3;rn elsern return 10;//出错情况rnrnint main()rnrn int c = 0;//用于一个一个读取字符rn string Str;rn cin >> Str;rn Length = Str.size();rn Stack StackObject(Length);//建立栈对象rn while (c < Str.size()) //通过c读取一个字符rn if (IsCharacter(Str.at(c))) //如果是字母就入栈rn StackObject.push(StringNode(Str.at(c)));rn rn else if (IsBiOperator(Str.at(c))) //如果是二目运算符,出栈两个节点后合成再入栈rn StringNode TempSN1 = StackObject.pop();rn StringNode TempSN2 = StackObject.pop();//注意出栈后的顺序rn StackObject.push(Compose(TempSN2, Str.at(c), TempSN1));//2在前面rn rn else if (IsSingleOperator(Str.at(c))) //如果是一目运算符rn StringNode TempSN = StackObject.pop();rn StackObject.push(Compose(TempSN, Str.at(c)));rn rn c++;rn rn StackObject.PrintStack();rnrnrnc版本:rn#includern#includern#includernstruct Node rn char NodeChar;rn struct Node *next;//每个节点存储一个字符和指向下一个节点的指针rn;rnstruct HeadNode //头结点记录表达式信息,有指向后续节点的头指针,后续节点数(字符数),以及表达式的优先级。一个头结点后面跟着一串结点链表代表一个表达式rn struct Node *head;rn int CharNum;rn int priority;rn;rnvoid Bracket(struct HeadNode *H) //给头结点指针H指向的头结点表示的表达式加括号rn int i;rn struct Node *p = (*H).head;rn struct Node *q;rn for (i = 0;i < ((*H).CharNum) - 1;i++) //一直把p移动到尾节点的前一个节点(指向尾节点)rn p = p->next;rn rn p->next = malloc(sizeof(struct Node));//尾指针新开辟一个节点rn p = p->next;//p指向这个新的尾节点rn (*p).NodeChar = ')';//尾节点上的字符时右括号rn p->next = NULL;//尾节点的尾指针为NULLrn q = malloc(sizeof(struct Node));//用一个指向节点的指针q申请一个节点rn q->next = (*H).head;rn q->NodeChar = '(';rn H->head = q;rn (H->CharNum) += 2;rn H->priority = 4;rnrnvoid AddChar(struct HeadNode *H, char c) rn int i;rn struct Node *p = (*H).head;rn for (i = 0;i < (*H).CharNum - 1;i++) //只移动到上一项,这样才能修改指针的值rn p = p->next;rn rn p->next = malloc(sizeof(struct Node));//这样才能真正改动Stack数组中的值rn p = p->next;rn p->NodeChar = c;rn p->next = NULL;rn (H->CharNum)++;rn if (c == '+' || c == '-') rn H->priority = 1;rn rn else if (c == '*' || c == '/') rn H->priority = 2;rn rn else if (c == '!') rn H->priority = 3;rn rnrnvoid Merge(struct HeadNode *H1, struct HeadNode *H2) rn int i;rn struct Node *p = (*H1).head;rn struct Node *q;rn for (i = 0;i < (*H1).CharNum - 1;i++) rn p = p->next;rn rn p->next = H2->head;rn (H1->CharNum) = (H1->CharNum) + (H2->CharNum);rn free(H2);rnrnvoid DeleteHeadNode(struct HeadNode *H) rn struct Node *j = (*H).head;rn struct Node *q = (*H).head;rn int i = (*H).CharNum;rnrn for (;i > 0;i--) rn q = q->next;rn free(j);rn j = q;rn rn free(H);rnrnrnmain() rn int i;rn char c;rn struct HeadNode ** Stack = NULL;rn int top = 0;rn while (c = getchar()) //getchar连回车都读入rn if (c == '\n')rn break;rn if (c >= 'a'&&c <= 'z') rn struct HeadNode *H = malloc(sizeof(struct HeadNode));rn if (H) rn H[0].priority = 4;rn H[0].head = malloc(sizeof(struct Node));rn H[0].CharNum = 1;rn H[0].head->NodeChar = c;rn H[0].head->next = NULL;rn if (!Stack) rn Stack = malloc(sizeof(struct HeadNode *));rn rn else rn Stack = realloc(Stack, sizeof(struct HeadNode *)*(top+1));rn rn Stack[top] = H;rn top++;rn rn else rn exit(0);rn rn rn else if (c == '!') rn int i;rn struct Node *p = (*(Stack[top - 1])).head;rn if ((*(Stack[top - 1])).priority < 3) rn Bracket(Stack[top - 1]);rn rn AddChar(Stack[top - 1], '!');rn rn else rn int cc;rn if (c == '+' || c == '-')rn cc = 1;rn else if (c == '*' || c == '/')rn cc = 2;rn if ((*(Stack[top - 2])).priority == 1 && (*(Stack[top - 1])).priority <= 2 && cc == 2) rn Bracket(Stack[top - 2]);rn Bracket(Stack[top - 1]);rn AddChar(Stack[top - 2], c);rn Merge(Stack[top - 2], Stack[top - 1]);rn top--;rn rn else if ((*(Stack[top - 2])).priority >= cc&&cc >= (*(Stack[top - 1])).priority) rn Bracket(Stack[top - 1]);rn AddChar(Stack[top - 2], c);rn Merge(Stack[top - 2], Stack[top - 1]);rn top--;rn rn else if ((*(Stack[top - 2])).priority < cc&&cc < (*(Stack[top - 1])).priority) rn Bracket(Stack[top - 2]);rn AddChar(Stack[top - 2], c);rn Merge(Stack[top - 2], Stack[top - 1]);rn top--;rn rn else rn AddChar(Stack[top - 2], c);rn Merge(Stack[top - 2], Stack[top - 1]);rn top--;rn rn rn rn struct Node *pp = (*(Stack[0])).head;rn for (i = 0;i < (*(Stack[0])).CharNum;i++, pp = pp->next) rn printf("%c", pp->NodeChar);rn rn DeleteHeadNode(Stack[0]);rn
中缀表达式转后缀表达式与括号匹配
1、算法思想1.1中缀转后缀表达式:从左到右依次扫描每个元素 (1)如果是左括号,直接入栈; (2)如果是右括号,则将栈中左括号以及之上的元素依次出栈,如果出栈的元素不是左括号,则加入后缀表达式中(这里用队列来存储,也可以直接输出); (3)如果是其他运算符,如果该操作符优先级比栈顶元素高则直接入栈;否则,依次出栈,加入后缀表达式中,直到如果该操作符优先级比栈顶元素高或者栈空为止;将该元素入栈
中缀表达式转后缀表达式 求值
#include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; #include&amp;lt;string&amp;gt; #include&amp;lt;stack&amp;gt; #include&amp;lt;cmath&amp;gt; #include&amp;lt;cstring&amp;gt; using namespace std; void Get(string a, char b[]);//中缀表达式转后缀...
中缀表达式转后缀表达式。求值
C++描述,用STL的栈实现。中缀转后缀,有注释。 打出求值的每一步。
中缀表达式转后后缀表达式
红的地方是错的?怎么改呢?rnrn│Error: Type mismatch in parameter 'toppt' in call to 'push' in function exprrnError: Type mismatch in parameter 'p' in call to 'push' in function exprrn│Error: Too few parameters in call to 'push' in function exprrn#include rn#include rn#include rnrntypedef struct nodern char data;rn int code;rn int pri;rn struct node *link;rnNODE;rnrnstruct Tb1rn char data;rn int code;rn int pri;rnopchTb1[]='*',1,4,'/',2,4,'+',3,2,'-',4,2,rn '(',5,5,')',6,1,'\0',7,0,'#',-1,0;rnrnNODE *optop;rnchar num[200],*numtop;rnchar expStr[200];rnrnvoid push(char x,int c,int p,NODE **toppt)rn NODE *q=(NODE*)malloc(sizeof(NODE));rn q->data=x;rn q->code=c;rn q->pri=p;rn q->link=*toppt;rn *toppt=q;rnrnrnint pop(char *op,int *cp,NODE **toppt)rn NODE*q=*toppt;rn if(*toppt==NULL) return 1;rn *op=q->data;rn *cp=q->code;rn *toppt=q->link;rn free(q);rn return 0;rnrnrnint expr(char *pos)rn struct Tb1 *op;rn char sop;rn int type,code,n,m,i,c;rnrn optop=NULL;rn numtop=num;rn n=m=0;rn c=' ';rnrn [color=#FF0000]push('#',0,0,*optop);[/color]while(1)rn while(c==' '|| c=='\t')rn c=*pos++;rn if(isalpha(c))rn *numtop++=' ';rn while(isalpha(c)|| isdigit(c))rn *numtop++=c;rn c=*pos++;rn rn if(m) return 1;rn m=1;rn continue;rn rn else rn for(i=0;opchTb1[i].code!=-1 && opchTb1[i].data!='c';i++)rn if(opchTb1[i].code==-1) return 3;rn op=&opchTb1[i];rn type=opchTb1[i].code;rn c=*pos++;rn rn if(type<5)rn if(m!=1) return 1;rn m=0;rn rn if(type==5) n++;rn if(type==6)rn if(n--==0) return 2;rn if(op->pri>optop->pri)rn [color=#FF0000]if(op->data=='(') push(op->code,1,&optop);[/color] else push(op->data,op->code,op->pri,&optop);rn elsern while(optop!=NULL && op->pri<=optop->pri)rn pop(&sop,&code,&optop);rn if(code<5 && code>0)rn *numtop++=' ';rn *numtop++=sop;rn rn rn if(op->data=='\0')rn return (n!=0 || (m!=1 && numtop>num))?4:(*numtop='\0');rn else if(op->data!=')')rn push(op->data,op->code,op->pri,&optop);rn rn rnrnrnrnrnvoid mian()rn int d;rn printf("please input expression:\n");rn gets(expStr);rn if((d=expr(expStr))==0)rn printf("postfix expression is:\n",num);rn elsern printf("syntax error formula! error types is %d:\n",d);rnZ
中缀表达式转后缀表达式(计算结果)
我们平常使用的式子都是中缀表达式。在程序中,我们可以利用栈,将中缀表达式转换为后缀表达式。也利用栈,将后缀表达式计算出结果。①中缀表达式转后缀表达式如1+2*3/(3-1)  ---&amp;gt;  1 2 3 * / 3 1 - +转换的思想:一个空的后缀表达式一个存放符号的栈s在转换的过程中,需要加入空格以区分不同数字与数字,数字与符号。(具体代码中体现)字符具体操作数字直接输出至后缀式中字符 '(...
相关热词 c# login 居中 c# 考试软件 c# 自然语言分析 c# 分段读取文件 c# 泛型反射 c#打断点 c# 时间转多少秒 c# 线程函数加参数 c# modbus 读取 c#查询集合表