c语言中后缀表达式求值

Ⅰ c语言 后缀表达式计算

while (c!='|')
{
a[i++]=c;
c=exp[k++];
}
//此处再加上a[i]='\0';表示字符串结束看看。

Ⅱ 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语言版表达式求值标准程序

思路：中缀表达式－后缀表达式－求值

参考代码：

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iterator>
#include <algorithm>

// 堆栈的数组实现，数组的大小固定。
template<class T>
class stack
{
private:
T *s; // 数组的首地址（栈底）
size_t N; // 指向栈顶第一个空闲块
const size_t size; // 堆栈的大小，固定不变

public:
stack(size_t n) : size(n)
{
s = new T[n]; // 可能抛出异常
N = 0; // 设置栈顶指针
}

~stack()
{
delete [] s;
}

bool empty() const
{
return N == 0;
}

bool full() const
{
return N == size;
}

void push(const T &object)
{
if (full())
{
throw "error: stack is full !";
}

s[N++] = object;
}

T pop()
{
if (empty())
{
throw "error: stack is empty !";
}

return s[--N];
}

T peek() const
{
if (empty())
{
throw "error: stack is empty !";
}

return s[N-1];
}

friend std::ostream& operator<<(std::ostream& os, const stack<T> &stk)
{
for (size_t i = 0; i < stk.N; i++)
{
std::cout << stk.s[i] << " ";
}

return os;
}
};

// 堆栈的链表实现
template<class T>
class STACK
{
private:
typedef struct node
{
T item;
node *next;
node(T x, node *t = NULL) : item(x), next(t) {}
}*link;

link head; // 指向栈顶第一个有效对象

public:
STACK(size_t n)
{
head = NULL;
}

~STACK() // 也可以用pop的方法删除，但效率低
{
link t = head;

while (t != NULL)
{
link d = t;
t = t->next;
delete d;
}
}

bool empty() const
{
return head == NULL;
}

bool full() const
{
return false;
}

void push(const T &object)
{
head = new node(object, head);
}

T pop()
{
if (empty())
{
throw "error: stack is empty !";
}

T v = head->item;
link t = head->next;
delete head;
head = t;
return v;
}

T peek() const
{
if (empty())
{
throw "error: stack is empty !";
}

return head->item;
}

friend std::ostream& operator<<(std::ostream& os, const STACK<T> &stk)
{
for (link t = stk.head; t != NULL; t = t->next)
{
std::cout << t->item << " ";
}

return os;
}
};

// 中缀表达式转化为后缀表达式，仅支持加减乘除运算、操作数为1位十进制非负整数的表达式。
char* infix2postfix(const char *infix, char *postfix)
{
const size_t N = strlen(infix);

if (N == 0 || postfix == NULL)
{
return postfix;
}

stack<char> opcode(N); // 堆栈存放的是操作符

for (size_t i = 0; i < N; i++)
{
switch (infix[i])
{
case '(': // 直接忽略左括号
break;

case ')': // 弹出操作符
*postfix++ = opcode.pop();
*postfix++ = ' ';
break;

case '+':
case '-':
case '*':
case '/':
opcode.push(infix[i]); // 压入操作符
break;

default:
if (isdigit(infix[i])) // 如果是数字，直接输出
{
*postfix++ = infix[i];
*postfix++ = ' ';
}
}
}

return postfix;
}

// 后缀表达式转化为中缀表达式，仅支持加减乘除运算、操作数为1位十进制非负整数的表达式。
char* postfix2infix(const char *postfix, char *infix)
{
const size_t N = strlen(postfix);

if (N == 0 || infix == NULL)
{
return infix;
}

*infix = '\0'; // 初始化输出字符串为空串
std::vector<std::string> v;

// 初始化，将所有有效字符放入容器
for (size_t i = 0; i < N; i++)
{
if (isdigit(postfix[i]) || postfix[i] == '+'
|| postfix[i] == '-' || postfix[i] == '*' || postfix[i] == '/')
{
v.push_back(std::string(1, postfix[i]));
}
}

// 处理每一个操作符
for (std::vector<std::string>::iterator b = v.begin(); b < v.end(); b++)
{
if (*b == "+" || *b == "-" || *b == "*" || *b == "/")
{
(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
std::cout << "------------------------------------------------" << std::endl;

std::string opcode = *(b);
std::string oprand1 = *(b - 2);
std::string oprand2 = *(b - 1);
b = v.erase(b - 2, b + 1); // 删除原来的三个表达式，用一个新的表达式替换
b = v.insert(b, std::string("(") + oprand1 + opcode + oprand2 + std::string(")"));
}
}

for (std::vector<std::string>::iterator b = v.begin(); b < v.end(); b++)
{
strcat(infix, (*b).c_str());
}

return infix;
}

// 计算后缀表达式的值，仅支持加减乘除运算、操作数为非负整数的表达式。
int postfix_eval(const char * postfix)
{
const size_t N = strlen(postfix);

if (N == 0)
{
return 0;
}

STACK<int> operand(N); // 堆栈存放的是操作数

for (size_t i = 0 ; i < N; i++)
{
switch (postfix[i])
{
int op1, op2;

case '+':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 + op2);
break;

case '-':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 - op2);
break;

case '*':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 * op2);
break;

case '/':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 / op2);
break;

default:

if (isdigit(postfix[i])) // 执行类似atoi()的功能
{
operand.push(0);

while (isdigit(postfix[i]))
{
operand.push(10 * operand.pop() + postfix[i++] - '0');
}

i--;
}
}

std::cout << operand << std::endl; // 输出堆栈的内容
}

return operand.pop();
}

// 本程序演示了如何后缀表达式和中缀表达式的相互转换，并利用堆栈计算后缀表达式。
// 转换方向：org_infix --> postfix --> infix
int main(int argc, const char *argv[])
{
// const char *org_infix = "(5*(((9+8)*(4*6))+7))"; // section 4.3
const char *org_infix = "(5*((9*8)+(7*(4+6))))"; // exercise 4.12
std::cout << "原始中缀表达式：" << org_infix << std::endl;

char *const postfix = new char[strlen(org_infix) + 1];
infix2postfix(org_infix, postfix);
std::cout << "后缀表达式：" << postfix << std::endl;

char *const infix = new char[strlen(postfix) + 1];
postfix2infix(postfix, infix);
std::cout << "中缀表达式：" << infix << std::endl;

std::cout << "计算结果是：" << postfix_eval(postfix) << std::endl;
std::cout << "计算结果是：" << postfix_eval("5 9*8 7 4 6+*2 1 3 * + * + *") << std::endl; // exercise 4.13

delete []infix;
delete []postfix;
return 0;
}

Ⅳ 如何用C语言数据结构的格式实现简单的算术表达式求值程序

用栈把中缀表达式(输入的式子）按优先级转为后缀表达式（逆波兰式，即运算符在前，操作数在后），再利用栈变计算边保存结果用于下一步计算，最后算出式子的答案
以下代码输入一个式子（以
=
作为输入结束标志），输出结果，负数如-3用0-3表示，支持高位运算
#include
<stdio.h>
#include
<stdlib.h>
#include
<math.h>
#include
<malloc.h>
#define
OK
1
#define
ERROR
-1
typedef
char
SElemType;
typedef
char
Status;
#define
STACK_INIT_SIZE
100000
#define
STACKINCREMENT
2
struct
SqStack
{
SElemType
*base;
SElemType
*top;
int
stacksize;
};
struct
SqStack1
{
int
*base;
int
*top;
int
stacksize;
};
SqStack
OPTR;
SqStack1
OPND;
char
Precede(char
c1,char
c2)
{
if(c1=='+'
||
c1=='-')
{
if(c2=='+'
||
c2=='-'
||
c2==')'
||
c2=='=')
return
'>';
else
return
'<';
}
else
if(c1=='*'
||
c1=='/')
{
if(c2=='(')
return
'<';
else
return
'>';
}
else
if(c1=='(')
{
if(c2==')')
return
'=';
else
return
'<';
}
else
if(c1==')')
return
'>';
else
if(c1=='=')
{
if(c2=='=')
return
'=';
else
return
'<';
}
else
return
'\0';
}
int
In(char
c)
{
if(c=='+'
||
c=='-'
||
c=='*'
||
c=='/'
||
c=='('
||
c==')'
||
c=='=')
return
1;
else
return
0;
}
int
Operrate(int
m,char
b,int
n)
{
switch(b)
{
case
'+':return
m+n;
case
'-':return
m-n;
case
'*':return
m*n;
case
'/':return
m/n;
}
return
0;
}
//操作数
int
InitStack1(SqStack1
&S)
{
S.base=(int
*)malloc(STACK_INIT_SIZE*sizeof(int));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push1(SqStack1
&S,int
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(int
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop1(SqStack1
&S,int
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
int
GetTop1(SqStack1
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
//算符
int
InitStack(SqStack
&S)
{
S.base=(SElemType
*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push(SqStack
&S,SElemType
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop(SqStack
&S,SElemType
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
Status
GetTop(SqStack
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
int
Calculate()
{
char
c,theta,p;
int
a,b,i=0,ans,x;
InitStack(OPTR);
Push(OPTR,'=');
InitStack1(OPND);
c=getchar();
while(c!='='
||
GetTop(OPTR)!='=')
{
if(!In(c)
&&
c>='0'
&&
c<='9')
{
Push1(OPND,c-'0');
c=getchar();
while(c>='0'
&&
c<='9')
{
Pop1(OPND,x);
Push1(OPND,x*10+c-'0');
c=getchar();
}
}
else
if(In(c))
{
switch(Precede(GetTop(OPTR),c))
{
case
'<':
Push(OPTR,c);
c=getchar();
break;
case
'=':
Pop(OPTR,p);
c=getchar();
break;
case
'>':
Pop(OPTR,theta);
Pop1(OPND,b);
Pop1(OPND,a);
ans=Operrate(a,theta,b);
Push1(OPND,ans);
break;
}
}
else
{
c=getchar();
}
}
return
GetTop1(OPND);
}
int
main()
{
int
ans;
ans=Calculate();
printf("%d\n",ans);
return
0;
}

Ⅳ 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语言计算表达式的值

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

Ⅶ 数据结构 后缀法表达式求值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语言的后缀表达式求值

#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语言数据结构实现后缀表达式求值

维系一个栈，表达式一个指针从前遍历到最后，是数的话，就压栈。
是运算的话，就退栈、计算，并将结果压缩。
计算机算这个很简单

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

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