後綴表達式求值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'結束