后缀表达式求值c语言

Ⅰ 数据结构 后缀法表达式求值c语言编写

#include<iostream>

usingnamespacestd;
#include<stdio.h>
#include<stdlib.h>
#defineadd43
#definesubs45
#definemult42
#definediv47
#defineMAXSIZE100
typedefstruct
{
intstkdata[MAXSIZE];
inttop;
}STKzone;
typedefSTKzone*STK;
typedefenum{True=1,False=0}boo;
typedefenum{ok,error}status;
STKzoneexpSTKzone;
STKexpSTK;
STKinitSTK(STKzone*stack_zone)
{
stack_zone->top=-1;
returnstack_zone;
}
statuspush(int*term,STKpstk)
{
if(pstk->top==MAXSIZE-1)
returnerror;
pstk->stkdata[++pstk->top]=*term;
returnok;
}/*push*/
boolemptySTK(STKpstk)
{
return(pstk->top==-1);
}
statuspop(int*pdata,STKpstk)
{
if(emptySTK(pstk))
returnerror;
else
{
*pdata=pstk->stkdata[pstk->top];
(pstk->top)--;
returnok;
}
}
voidsynerror()
{
printf("
表达式语法错误！
");
exit(0);
}
inteval(inta1,inta2,chartag)
{
switch(tag)
{
caseadd:
return(a1+a2);
casesubs:
return(a1-a2);
casemult:
return(a1*a2);
casediv:
return(a1/a2);
}
}
intmain()
{
charc;
intopd1,opd2,temp,c1;
expSTK=initSTK(&expSTKzone);
opd1=1;
opd2=2;
push(&opd1,expSTK);
push(&opd2,expSTK);
printf("
后缀表达式:");
while((c=getchar())!='/n')
{
if(c=='')continue;
if((c>47)&&(c<58))
{
c1=c-48;
if(push(&c1,expSTK)==error)
{
printf("表达式太长
");
exit(0);
}
}
elseif((c==add)||(c==subs)||(c==mult)||(c==div))
{
if(pop(&opd1,expSTK)==error)
synerror();
if(pop(&opd2,expSTK)==error)
synerror();
temp=eval(opd1,opd2,c);
push(&temp,expSTK);
}
else{
//你输入的c是多少，根本就不对
printf("c=[%c],c=%0X
",c,c);
synerror();
}
}/*while*/
if(pop(&temp,expSTK)==error)synerror();
if(!(emptySTK(expSTK)))synerror();
printf("=%-3d
",temp);
return0;
}/*main_end*/
//执行程序看看，你输入的c值是多少，重新设计一下吧

Ⅱ C语言计算表达式的值

逗号运算符
左至右计算
取
表达式
值作
整
语句
值
先算a=3,
a赋值
3
算b=4,
b赋值
4
计算c=a+b
实际
c=3+4
c
值
7
终整条语句
值
c
值7.

Ⅲ 谁有c语言的后缀表达式求值

#include<stdio.h>
#define STACKINCREMENT 10
#define stacksize 100
#define OK 1
#define ERROR 0
#define Status char
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}Sqtack;

Status precede(GetTop(OPTR),c)
{
if(GetTop(OPTR)=='+'||GetTop(OPTR)=='-')
if(c=='+'||c=='-'||c==')'||c=='#')
return('>');
else
return('<');
if(GetTop(OPTR)=='*'||GetTop(OPTR)=='/')
if(c=='(')
return('<');
else
return('>');
if(GetTop(OPTR)=='(')
if(c==')')
return('=');
if(c=='#')
return(' ');
else
return('<');
if(GetTop(OPTR)==')')
if(c=='(')
return(' ');
else
return('>');
if(GetTop(OPTR)=='#')
if(c=='#')
return('=');
if(c==')')
return( );
else
return('<');
}
Status In(c,OP)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
return(1);
else
return(0);
}
Status Operate(a,theta,b)
{
status sum,m,n;
m=*a,n=*b;
if(theta=='*')
sum=m*n;
if(theta=='/')
sum=m/n;
if(theta=='+')
sum=m+n;
if(theta=='-')
sum=m-n;
return(sum);
}
OperandType EvaluateExpression()
{
Status a,b,c;
InitStack(OPTR);
push(OPTR,'#' );
Initstack(OPND);
c=getchar();
while(c!='#'||Gettop(OPTR)!='#')
{
if(!In(c,OP)){Push(OPND,c);c=getchar();}
else
swtich(precede(Gettop(OPTR),c))
{case'<':Push(OPTR,c);c=getchar;break;
case'=':Pop(OPTR,x);c=getchar();break;
case'>':Pop(OPTR,theta);Pop(OPND,b);pop(OPND,a);Push(OPND,operate(a,theta,b));break;

}
}
return GetTop(OPND);
}
Status InitStack(SqStack *OPTR)
{
OPTR->base=(SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType ));
if(!OPTR->base) exit (OVERFLOW);
OPTR->top=OPTR->base;
OPTR->stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack *OPTR,SElemType e)
{
if(OPTR->top-OPTR->base>=OPTR->stacksize)
{
OPTR->base=(SElemType *)realloc(OPTR->base,(OPTR->stacksize+STACKINCREMENT)*sizeof(SElemType ));
if(!OPTR->base) exit (OVERFLOW);
OPTR->top=OPTR->base+OPTR->stacksize;
OPTR->stacksize+=STACKINCREMENT;
}
*(OPTR->top)=e;OPTR->top++;
return OK;
}
Status GetTop(SqStack OPTR,SElemType *p)
{
if(OPTR.top==OPTR.base) return ERROR;
*p=*(OPTR.top-1);
return OK;
}
SElemType Pop(SqStack *OPTR)
{
SElemType e;
if(OPTR->top==OPTR->base) return ERROR;
e=*--OPTR->top;
return e;
}
Status InitStack(SqStack *OPND)
{
OPND->base=(SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType ));
if(!OPND->base) exit (OVERFLOW);
OPND->top=OPND->base;
OPND->stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack *OPND,SElemType e)
{
if(OPND->top-OPND->base>=OPND->stacksize)
{
OPND->base=(SElemType *)realloc(OPND->base,(OPND->stacksize+STACKINCREMENT)*sizeof(SElemType ));
if(!OPND->base) exit (OVERFLOW);
OPND->top=OPND->base+OPND->stacksize;
OPND->stacksize+=STACKINCREMENT;
}
*(OPND->top)=e;OPND->top++;
return OK;
}
SElemType Pop(SqStack *OPND)
{
SElemType e;
if(OPND->top==OPND->base) return ERROR;
e=*--OPND->top;
return e;
}
main()
{
float result;
EvaluateExpression();

}


Ⅳ c语言后缀表达式求值详细程序，可运行的

#include <iostream>

#include <string.h>

using namespace std;

template <class T>

class Stack

{

private:

T *s;

int maxlength;

int top;

public:

Stack(int max)

{

maxlength=max;

s=new T[max];

top=-1;

}

bool isFull()

{

return top==maxlength-1;

}

bool isEmpty()

{

return top==-1;

}

T getTopElement()

{

return s[top];

}

void push(T x)

{

if(isFull())

return;

s[++top]=x;

}

T pop()

{

if(isEmpty())

return '!';

T tmp=s[top];

top--;

return tmp;

}

void clear()

{

top=-1;

}

void traverse()

{

for (int i=0;i<=top;i++)

{

cout<<s[i]<<" ";

}

cout<<endl;

}

};

class Calculator

{

private:

char *f;

int maxlength;

Stack<double> *s;

Stack<char> *t;

int getP(char t)

{

switch(t)

{

case '+':

return 0;

break;

case '-':

return 0;

break;

case '*':

return 1;

break;

case '/':

return 1;

break;

}

return -1;

}

double getResult(char *f)

{

s->clear();

int l=strlen(f);

for(int i=0;i<l;i++)

{

if(f[i]>='0'&&f[i]<='9')

s->push(f[i]-'0');

else

{

double x2=s->pop();

double x1=s->pop();

switch(f[i])

{

case '+':

s->push(x1+x2);

break;

case '-':

s->push(x1-x2);

break;

case '*':

s->push(x1*x2);

break;

case '/':

s->push(x1/x2);

break;

}

}

// s->traverse();

}

double res=s->pop();

return res;

}

public:

Calculator(int max)

{

maxlength=max;

s=new Stack<double>(max);

t=new Stack<char>(max);

}

double run(char *input)

{

char *opt=new char[maxlength];

char *inp=new char[strlen(input)+2];

int cnt=0,l=strlen(input)+2;

for(int i=0;i<l-2;i++)

inp[i]=input[i];

inp[l-2]='#';

inp[l-1]=0;

cout<<inp<<endl;

t->push('#');

for(int i=0;i<l;i++)

{

if(inp[i]>='0'&&inp[i]<='9')

opt[cnt++]=inp[i];

else

{

if(t->getTopElement()=='#' || getP(t->getTopElement())<getP(inp[i]) || inp[i]=='(')

t->push(inp[i]);

else if(inp[i]=='#')

{

while(!t->isEmpty()&&t->getTopElement()!='#')

opt[cnt++]=t->pop();

}

else if(inp[i]==')')

{

while(!t->isEmpty()&&t->getTopElement()!='(')

opt[cnt++]=t->pop();

t->pop();

}

else if(getP(t->getTopElement())>=getP(inp[i]))

{

while(!t->isEmpty()

&&getP(t->getTopElement())>=getP(inp[i])

&&t->getTopElement()!='(')

opt[cnt++]=t->pop();

t->push(inp[i]);

}

}

cout<<"stack:T: ";

t->traverse();

}

opt[cnt]=0;

cout<<opt<<endl;

return getResult(opt);

}

};

int main()

{

Calculator c(30);

int a[2005];

freopen("rpncalc.in","r",stdin);

freopen("rpncalc.out","w",stdout);

cin>>a;

cout<<c.run("a")<<endl;

}

Ⅳ C语言关于表达式求值

c语言有丰富的表达式，这是它的特点之一，表达式主要有4类，算术表达式，赋值表达式，逗号表达式，关系表达式
1.算术表达式就是包含算术运算符（如+
-
/
*
%等）的表达式（不是语句，后面没有分号），如：a+b
，a%b，a+b-c*d，3+5等，算术表达式的值就是最后算出的结果，如3+5这个表达式的值就是8
2.赋值表达式，就是含有赋值运算符=的表达式，如a=5，b=3，c='a'等，=左边的a,b,c称为左值，必须为变量，=右边的5,3,'a'称为右值，必须为常量，赋值表达式的值为右值，如a=3的值为3，c='a'的值为字母a的ascii码65（当然也可以认为它的值就是字母a）
3.逗号表达式就是含有逗号的表达式，形式：表达式1，表达式2，表达式3.......如a,b,c
3,5,7
a=3,b=4,c=6
3,a=5,b=6等
逗号表达式的值为，最右边的表达式的值，如3,4,5的值就是5，表达式a=3,b=4,c=6的值就是表达式b=6的值，由上述分析知，表达式b=6的值就是6，所以表达式a=3,b=4,c=6的值就是6
4.关系表达式，指含有关系运算符（如>
<
>=
==
=<等）的表达式（其实也是算术表达式的一种）如a>b,a>6,6>5,3<2,4==6等，如果表达式的关系是正确的，那么表达式的值为1，否则为0
如6>5正确，表达式的值为1,3<2,和4==6错误，表达式的值为0
当然可以细分为很多种表达式，不过主要也就是这几种的变型，希望对你有所帮助

Ⅵ 表达式求值（C语言 数据结构栈）急求。。。。。

其实不用这样子的，要将表达式的值赋值就行了。

Ⅶ c语言后缀表达式求值遇到二位数怎么求

如果原始数据不是一位数，则转化为后缀表达式的时候不能简单的转，需要增加分隔符，例如空格或者逗号，用以划分各个运算数字。

Ⅷ C语言代码补全：前缀表达式求值

思路：这里实际是把前缀表达式逆序输出转化为类似后序表达式求值：
比如：

输入：++2*3-74/84处理成48/47-3*2++链表，放到后缀表达式求值程序postFixEval计算得

13.0
#include<stdio.h>
#include<stddef.h>
#include<string.h>
#include<stdlib.h>
#defineMAXSIZE100
//用链表实现前缀表达式，
typedefstructNode
{
union
{charexp;
inta;
}data;
structNode*next;
structNode*prev;
}Node;
intisExpression(inttmpExp){
if(tmpExp=='+'||tmpExp=='-'||tmpExp=='/'||tmpExp=='*'||tmpExp=='('||tmpExp==')')
return1;
else
return0;
}
intisSuperior(inttmpExp,inttmpExp2){
if(tmpExp2=='('||(tmpExp=='/'||tmpExp=='*'))//tmpExp2=='('||(tmpExp=='/'||tmpExp=='*')&&(tmpExp2=='+'||tmpExp2=='-')
return1;
else
return0;
}

voidprintNode(Node*node)
{
if(node)
{chartmpExp=node->data.exp;
if(isExpression(tmpExp))
printf("%c",node->data.exp);
else
printf("%d",node->data.a);
if(node)
printNode(node->next);
}
}
typedefstructStack2
{doublearr[MAXSIZE];
inttop;
}Stack2;
voidpush(doublenum,Stack2*stack)
{if(stack->top>=MAXSIZE)
return;
else
{stack->top++;
(stack->arr[stack->top]=num);
}
}

doublepop(Stack2*stack)
{doubleret;
if(stack->top<=-1)
return-1;
else
{ret=stack->arr[stack->top];stack->top--;}
returnret;
}
//后缀表达式求值程序
doublepostFixEval(Node*head)
{doubleval=0;
Node*node=head;
Stack2stack2;
stack2.top=-1;
while(node)
{
if(!isExpression(node->data.exp))
{
push(node->data.a,&stack2);
}
else
{
doubleop1=pop(&stack2);
doubleop2=pop(&stack2);
switch(node->data.exp)
{
case'+':
val=op1+op2;
break;
case'-':
val=op1-op2;//注意是op1/op2
break;
case'*':
val=op1*op2;
break;
case'/':
val=op1/op2;//注意是op1/op2
break;
}
push(val,&stack2);
}
node=node->next;
}
returnval=pop(&stack2);
}

intmain(intargc,char*argv[])
{
Node*head=0;
inti=0,length=0;
charbuf[1024];
char*tmpExp,sep[]="";
char*p=NULL;
//head=(Node*)malloc(sizeof(Node));
//head->data.exp='';
//head->data.a=0;
//head->next=0;
gets(buf);
tmpExp=buf;
Node*tmpExpNode=head;
//输入为前缀表达式
while(p=strtok(tmpExp,sep))
{
Node*node=(Node*)malloc(sizeof(Node));
node->next=0;
//printf("%s",p);pisapointtostring(notapointtoachar)
if(strcmp(p,"+")==0||strcmp(p,"+")==0||strcmp(p,"-")==0||strcmp(p,"*")==0||strcmp(p,"/")==0||strcmp(p,"(")==0||strcmp(p,")")==0)
sscanf(p,"%c",&node->data.exp);
else
sscanf(p,"%d",&node->data.a);
node->next=tmpExpNode;//逆转输入的前序表达式，即后输入的在前
tmpExpNode=node;
tmpExp=0;
}
printf("%0.1f
",postFixEval(tmpExpNode));//0.1f表示一位小数
return0;
}

Ⅸ 求助C语言后缀表达式计算结果

你把一位数的处理程序提供一下，我帮你调整成可以处理多位数的

Ⅹ C语言数据结构：后缀表达式求值

char a[10] = "11+";//字符串自动以'\0'结束