① 编写程序对表达式求值c语言，该如何处理
先读取输入表达式，转为前缀或者后缀形式。
然后再处理转换后的表达式进行求值。
这个是很常见的一个数据结构题目，网上有很多参考代码的。
② C语言 任意表达式求值。（栈的应用
/*** 只适合整数的表达式求值 ***/
/***其中部分可作修改，表达式也可是输入的***/
#include "iostream.h"
const int n0=30;
int s1[n0+1]; //操作数栈
char s2[n0+1]; //运算符栈
int t1,t2;
int num[4]; //提取表达式中的整数
void calcu() //一次计算
{
int x1,x2,x;
char p;
//弹出一个运算符
p=s2[t2--];
//弹出两个操作数
x2=s1[t1--];
x1=s1[t1--];
//进行一次运算
switch(p) {
case '+':x=x1+x2;break;
case '-':x=x1-x2;break;
case '*':x=x1*x2;break;
case '/':x=x1/x2;
}
//结果压入操作数栈
s1[++t1]=x;
}
int calculator(char *f)
{
int v,i=0;
char *p=f;
t1=t2=0; //设置空栈
while (*p!='\0')
switch(*p) {
case '+': case '-':
while (t2&&(s2[t2]!='('))
//执行先遇到的加、减、乘、除运算
calcu();
//当前运算符进栈
s2[++t2]=*p;
//读下一个字符
p++;
break;
case '*': case '/':
if (t2&&(s2[t2]=='*')||(s2[t2]=='/'))
//执行先遇到的乘、除运算
calcu();
//当前运算符进栈
s2[++t2]=*p;
//读下一个字符
p++;
break;
case '(':
//左括号进栈
s2[++t2]=*p;
//读下一个字符
p++;
break;
case ')':
while (s2[t2]!='(')
//执行括号内的加、减、乘、除运算
calcu();
//弹出左括号
t2--;
//读下一个字符
p++;
break;
default:
//把字符串转换成整数值
v=0;
do {
v=10*v+*p-'0';
p++;
} while((*p>='0')&&(*p<='9'));
//操作数进栈
s1[++t1]=v;
num[i++]=v;
};
//执行先遇到的加、减、乘、除运算
while (t2) calcu();
//返回结果
return s1[t1];
}
void main()
{
char a[]="5*(40+6)-39";
cout<<calculator(a)<<endl;
cout<<"其中的数字为：\n";
for (int i=0;i<4;i++)
{
cout<<num[i]<<' ';
}
cout<<endl;
}
原来做过的东西，是C++的，VC++6.0环境下调试运行成功。
③ C语言表达式求值
//表达式求值
//By:jimly
//10/10/2009
//例如：输入2+2（4-6*3）=
//以"="结束,然后回车即出结果
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <assert.h>
typedef float ElemType;
typedef struct Stack
{
ElemType *base; // 栈基址
ElemType *top; // 栈顶
int stacksize; // 栈存储空间的尺寸
} SqStack;
/*------------------------------------------------------------
// 栈的基本操作
------------------------------------------------------------*/
bool InitStack(SqStack *S);
bool InitStack(SqStack *S);
void DestroyStack(SqStack *S);
bool StackEmpty(SqStack S);
int StackLength(SqStack S);
ElemType GetTop(SqStack S, ElemType *e);
void StackTraverse(SqStack S, void (*fp)(ElemType));
bool Push(SqStack *S, ElemType e);
bool Pop(SqStack *S, ElemType *e);
/*------------------------------------------------------------
// 表达式求值的操作函数定义
------------------------------------------------------------*/
char Precede(char A1,char A2);
ElemType Operate(ElemType a,ElemType theta,ElemType b);
bool In(char c,char op[]);
ElemType EvaluateExpression();
void Menu();//////////////////////////////////////////////
// Eval_exdivssion.cpp 表达式求值实现函数 //
//////////////////////////////////////////////
/*------------------------------------------------------------
操作目的： 判定运算符栈的栈顶运算符A1和读入的运算符A2之间优先关系的函数
初始条件： 无
操作结果： 判断出优先关系
函数参数：
char A1 运算符
char A2 运算符
返回值：
char 大小关系
------------------------------------------------------------*/
char Precede(char A1,char A2)
{
if (A1 == '+' || A1 == '-')
{
if (A2 == '+' || A2 == '-' || A2 == ')' || A2 == '=')
{
return '>';
}
else
return '<';
}
if (A1 == '*' || A1 == '/')
{
if (A2 == '(')
{
return '<';
}
else
return '>';
}
if (A1 == '(')
{
if (A2 == ')')
{
return '=';
}
if (A2 == '=')
{
return 'E';
}
else
return '<';
}
if (A1 == ')')
{
if (A2 == '(')
{
return 'E';
}
if (A2 == '=')
{
return 'E';
}
else
return '>';
}
if (A1 == '=')
{
if (A2 == '=')
{
return '=';
}
else
return '<';
}
else
return '=';
}
/*------------------------------------------------------------
操作目的： 二元运算a与b的函数
初始条件： 无
操作结果： 返回运算结果
函数参数：
ElemType a 操作数
ElemType theta 操作符
ElemType b 操作数
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType Operate(ElemType a,ElemType theta,ElemType b)
{
switch(char(theta))
{
case '+':
return a += b;
break;
case '-':
return a -= b;
break;
case '*':
return a *= b;
break;
case '/':
if(b==0)
{
printf("除数不能为0！！\n");
exit(0);
}
return a /= b;
break;
} return 0;
}
/*------------------------------------------------------------
操作目的： 判断字符c是否属于运算符集合op
初始条件： 无
操作结果： 返回判断结果
函数参数：
char c 要判断的字符
char op[] 运算符集合
返回值：
bool 属于返回true 否则返回false
------------------------------------------------------------*/
bool In(char c,char op[])
{
for (int i = 0;i<7;i++)
{
if (op[i] == c)
return true;
}
return false;
}
/*------------------------------------------------------------
操作目的： 算术表达式求值的运算符优先算法
初始条件： 无
操作结果： 返回表达式的值
函数参数：
无
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType EvaluateExpression()
{
SqStack OPTR; //运算符栈
SqStack OPND; //运算数栈
char Ct = '='; //判断是否结束的标识
int i = 0,j = 1;
ElemType e = 0,t = 0,c;
char op[7] = {'+','-','*','/','(',')','='}; InitStack(&OPTR); //初始化
Push(&OPTR,Ct);
InitStack(&OPND); //初始化 c = (float)getchar();
while (c!='=' || GetTop(OPTR,&e)!='=')
{
if (!In((char)c,op)) //不是运算e符进栈
{
while(!In((char)c,op)) //可以是几位数
{
t = t*10+(c-48);
c = (float)getchar();
}
Push(&OPND,t);
t = 0;
} else
{
switch (Precede((char)GetTop(OPTR,&e),(char)c))
{
case '<'://栈顶元素优先权低
Push(&OPTR,c);
c = (float)getchar();
break;
case '='://脱括号并接受下个字符
ElemType x;
Pop(&OPTR,&x);
c = (float)getchar();
break;
case '>'://退栈并将运算结果入栈
ElemType b,theta,a;
Pop(&OPTR,&theta);
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND,Operate(a,theta,b));
break;
case 'E':
printf("括号不匹配！！\n");
exit(0);
break;
}
}
}
ElemType tem = GetTop(OPND,&e);
DestroyStack(&OPND);
DestroyStack(&OPTR);
return tem;
}/***
*DynaSeqStack.cpp - 动态顺序栈，即栈的动态顺序存储实现
****/
const int STACK_INIT_SIZE = 100; // 初始分配的长度
const int STACKINCREMENT = 10; // 分配内存的增量
/*------------------------------------------------------------
操作目的： 初始化栈
初始条件： 无
操作结果： 构造一个空的栈
函数参数：
SqStack *S 待初始化的栈
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool InitStack(SqStack *S)
{
assert(S != NULL);
S->base = (ElemType *)malloc(sizeof(ElemType) * STACK_INIT_SIZE);
if(S->base == NULL) return false; S->top = S->base;
S->stacksize = STACK_INIT_SIZE; return true;
}/*------------------------------------------------------------
操作目的： 销毁栈
初始条件： 栈S已存在
操作结果： 销毁栈S
函数参数：
SqStack *S 待销毁的栈
返回值：
无
------------------------------------------------------------*/
void DestroyStack(SqStack *S)
{
assert(S != NULL); free(S->base);
S->top = S->base = NULL;
}/*------------------------------------------------------------
操作目的： 判断栈是否为空
初始条件： 栈S已存在
操作结果： 若S为空栈，则返回true，否则返回false
函数参数：
SqStack S 待判断的栈
返回值：
bool 是否为空
------------------------------------------------------------*/
bool StackEmpty(SqStack S)
{
assert((S.base != NULL) && (S.top != NULL));
return(S.base == S.top);
}/*------------------------------------------------------------
操作目的： 得到栈的长度
初始条件： 栈S已存在
操作结果： 返回S中数据元素的个数
函数参数：
SqStack S 栈S
返回值：
int 数据元素的个数
------------------------------------------------------------*/
int StackLength(SqStack S)
{
assert((S.base != NULL) && (S.top != NULL));
return(S.top-S.base);
}/*------------------------------------------------------------
操作目的： 得到栈顶元素
初始条件： 栈S已存在
操作结果： 用e返回栈顶元素
函数参数：
SqStack S 栈S
ElemType *e 栈顶元素的值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
ElemType GetTop(SqStack S, ElemType *e)
{
assert((S.base != NULL) && (S.top != NULL));
if(StackEmpty(S)) return false; *e = *(S.top-1);
return *e;
}/*------------------------------------------------------------
操作目的： 遍历栈
初始条件： 栈S已存在
操作结果： 依次对S的每个元素调用函数fp
函数参数：
SqStack S 栈S
void (*fp)() 访问每个数据元素的函数指针
返回值：
无
------------------------------------------------------------*/
void StackTraverse(SqStack S, void (*fp)(ElemType))
{
assert((S.base != NULL) && (S.top != NULL));
for(; S.base<S.top; S.base++) (*fp)(*S.base);
}/*------------------------------------------------------------
操作目的： 压栈——插入元素e为新的栈顶元素
初始条件： 栈S已存在
操作结果： 插入数据元素e作为新的栈顶
函数参数：
SqStack *S 栈S
ElemType e 待插入的数据元素
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Push(SqStack *S, ElemType e)
{
if (S->top - S->base>=S->stacksize)
{
S->base = (ElemType *)realloc(S->base,(S->stacksize + STACKINCREMENT) * sizeof(ElemType));
if (!S->base)
exit(0);
S->top = S->base + S->stacksize;
S->stacksize += STACKINCREMENT;
}
*S->top++ = e; return true;
}/*------------------------------------------------------------
操作目的： 弹栈——删除栈顶元素
初始条件： 栈S已存在且非空
操作结果： 删除S的栈顶元素，并用e返回其值
函数参数：
SqStack *S 栈S
ElemType *e 被删除的数据元素值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Pop(SqStack *S, ElemType *e)
{
if(S == NULL) return false;
assert((S->base != NULL) && (S->top != NULL));
if(StackEmpty(*S)) return false; *e = *(--S->top);
return true;
}//////菜单///////
void Menu()
{
printf("表达式求值模拟程序\n\n");
printf("功能菜单：\n");
printf("==============\n");
printf("[1] 输入表达式并求值\n");
printf("[0] 退出 \n");
printf("==============\n");
printf("请输入你的选择(0~1)（以回车结束）：");
}///////// 主函数 ///////////
//////////////////////////////
int main()
{
char ch = ' ',tp; do
{
system("cls");
Menu();
ch = getchar();
if (ch == '0')
break;
tp = getchar();
printf("请输入一个表达式（最后输入”=“,然后回车出结果）：");
printf("这个表达式结果为：%g\n",EvaluateExpression());
tp = getchar();
printf("任意键继续...");
getch();
} while (true); return 0;
}//end
④ c语言表达式求值
#include"stdio.h"
#include"malloc.h"
#include"math.h"
#include"stdlib.h"
#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef char SElemType;
typedef char OpeandType;
typedef struct
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
Status InitStack (SqStack &S);
char GetTop(SqStack S);
Status Push(SqStack &S,SElemType e);
Status Pop(SqStack &S,SElemType &e);
char Precede(char t,char c);
int In(char c);
int Operate(SElemType a,SElemType theta,SElemType b);//
OpeandType EvaluateExpression();
Status InitStack (SqStack &S)
{
//构造一个空栈
S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStatus
char GetTop(SqStack S)
{
//若栈不为空，则用e返回s的栈顶元素，并返回OK；否则返回ERROR
SElemType e;
if(S.top==S.base)return ERROR;
e=*(S.top-1);
S.top =S.top +1;
return e;
}//GetTop
Status Push(SqStack &S,SElemType e)
{
//插入元素e为新的栈顶元素
if((S.top-S.base)>=S.stacksize)
{
//栈满，追加存储空间
S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);//存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;//
return OK;
}//Push
Status Pop(SqStack &S,SElemType &e)
{
//若栈不为空，则删除s的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(S.top==S.base)return ERROR;
e=*(--S.top);
return OK;
}//Pop
char Precede(char t,char c)
{
switch(c)
{
case '+':
if(t=='+'||t=='-'||t=='*'||t=='/'||t==')')
return '>';
else
return'<';
break;
case '-':
if(t=='+'||t=='-'||t=='*'||t=='/'||t==')')
return '>';
else
return '<';
break;
case '*':
if(t=='*'||t=='/')
return '>';
else
return '<';
break;
case '/':
if(t=='*'||t=='/')
return '>';
else
return '<';
break;
case '(':
return '<';
break;
case ')':
if(t=='(')
return '=';
else
return '>';
break;
case '#':
if(t=='#')
return '=';
else
return '>';
break;
}
return 'h';
}//Precede
int In(char c)
{
switch(c)
{
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
case '#':
return OK;
break;
}
return 0;//
}//判断c是否为运算符，是则返回1，否则返回0
int Operate(SElemType a,SElemType theta,SElemType b)//
{
int x,y;
x=a-'0';
y=b-'0';
switch(theta)
{
case '-':return x-y;
case '*':return x*y;
case '/':
if(y==0)
return 0;
return x/y;
case '+':return x+y;
default :return 0;
}
}
OpeandType EvaluateExpression()
{
//算术表达式求值的算符优先法。设OPTR和OPND分别为算符栈和运算数栈，
//OP为运算符集合。
SqStack OPTR,OPND;
SElemType e;
int k;//
SElemType t;
//int kk=0;
SElemType theta,a,b,f;
InitStack(OPTR);
Push(OPTR,'#');
InitStack(OPND);
SElemType c;//
c=getchar();
while(c != '#'||(GetTop(OPTR))!='#')
{
if(!In(c))
{//不是运算符者进栈
Push(OPND,c);
c=getchar();
}
else
{
switch(Precede(GetTop(OPTR),c))
{
case '<'://栈顶元素优先权低
Push(OPTR,c);
c=getchar();//
break;
case '='://脱括号并接收下一个字符
Pop(OPTR,t);
c=getchar();//
break;
case'>'://退栈并将运算结果入栈
Pop(OPTR,theta);
Pop(OPND,b);
Pop(OPND,a);
k=Operate(a,theta,b);//
f=k+'0';//
Push(OPND,f);//
break;
}//switch
}
}///while
e=GetTop(OPND);
if(!e)
return 'k';
return e;
//printf("endl");
}
void main()
{
char sum;
printf("请输入你要运算的表达式(以‘#’号键结束)：");
sum=EvaluateExpression();
printf("运算结果是：%c\n",sum);
}
可以运行10 以内的，结果超过10就不行了，中途也是，如果要超过10的话，再说
⑤ 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"stdio.h"
#include"malloc.h"
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintStatus;
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
//构造一个空栈
StatusInitStack(SqStack*S){
S->base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S->base)
exit(OVERFLOW);
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
returnOK;
}
//判断是否为空栈
StatusStackEmpty(SqStackS){
if(S.top==S.base)
returnTRUE;
else
returnFALSE;
}
//用e返回S的顶元素
StatusGetTop(SqStackS,SElemType*e){
if(S.top==S.base)
returnERROR;
*e=*(S.top-1);
returnOK;
}
//插入e为新的顶元素
StatusPush(SqStack*S,SElemTypee){
if((S->top-S->base)>=S->stacksize){
S->base=(
SElemType*)realloc(S->base,
(S->stacksize+STACKINCREMENT)*sizeof(SElemType)
);
if(!S->base)
exit(OVERFLOW);
S->top=S->base+S->stacksize;
S->stacksize+=STACKINCREMENT;
}
*(S->top)=e;
S->top++;
returnOK;
}
//删除S的顶元素，并用e返回其值
StatusPop(SqStack*S,SElemType*e){
if(S->top==S->base)
returnERROR;
S->top--;
*e=*(S->top);
returnOK;
}
//从栈底到栈顶依次对S的每个元素调用函数Visit（），一旦失败操作无效
StatusListTraverse(SqStackS,Status(*visit)(SElemType)){
SElemType*p;
p=S.base;
for(p=S.base;p<S.top;p++)
(*visit)(*p);
returnOK;
}
//输出元素e
Statusoutput(SElemTypee){
printf("%d",e);
returnOK;
}
⑦ 怎么用C语言栈实现表达式求值
这个问题不是一两句话可以解释清楚的。这个要涉及到计算机编译原理课程的基本知识。其主要技术涉及到：表达式的分析与求值。表达式的分析与求值分为：前缀、中缀、及后缀。再具体的编程必须要参考 C 语言编程的书籍。我那会儿编程使用的书籍是《C 语言大全》，该书虽然比较老了，但是上面有很多现成的源代码可供参考。
⑧ 编写程序对表达式求值C语言
#include "stdio.h"
#include "malloc.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
//构造一个空栈
Status InitStack(SqStack *S){
S->base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S->base)
exit(OVERFLOW);
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
return OK;
}
//判断是否为空栈
Status StackEmpty(SqStack S){
if(S.top == S.base)
return TRUE;
else
return FALSE;
}
//用e返回S的顶元素
Status GetTop(SqStack S, SElemType *e){
if(S.top == S.base)
return ERROR;
*e = *(S.top-1);
return OK;
}
//插入e为新的顶元素
Status Push(SqStack *S, SElemType e){
if((S->top - S->base) >= S->stacksize){
S->base = (
SElemType*)realloc(S->base,
(S->stacksize+STACKINCREMENT)*sizeof(SElemType)
);
if(!S->base)
exit(OVERFLOW);
S->top = S->base +S->stacksize;
S->stacksize += STACKINCREMENT;
}
*(S->top)=e;
S->top++;
return OK;
}
//删除S的顶元素，并用e返回其值
Status Pop(SqStack *S, SElemType *e){
if(S->top == S->base)
return ERROR;
S->top--;
*e = *(S->top);
return OK;
}
//从栈底到栈顶依次对S的每个元素调用函数Visit（），一旦失败操作无效
Status ListTraverse(SqStack S,Status (*visit)(SElemType)){
SElemType *p;
p=S.base;
for(p=S.base;p<S.top;p++)
(*visit)(*p);
return OK;
}
//输出元素e
Status output(SElemType e){
printf("%d ",e);
return OK;
}
实现表达式求值的代码：
/*计算整数表达式的值
*表达式必须以#结束
*表达式中可以出现多位数字，
*表达式中可以出现空格
*运算符包括+,-,*,/,(,)
*运算结果可以是多位整数，并以整数的形式返回
*/
typedef int SElemType; /*放入堆栈的元素的类型*/
#include <ctype.h>
#include "stack_s.c"
/*判断输入的某个字符是否是运算符
*c表示输入的字符
*op数组中存放系统能识别的运算符
*/
Status in(char c,char op[]){
char *p;
p=op;
while(*p != '\0'){
if(c == *p)
return TRUE;
p++;
}
return FALSE;
}
/*比较两个运算符的优先级
*a，b中存放待比较的运算符
*'>'表示a>b
*'0'表示不可能出现的比较
*/
char Precede(char a, char b){
int i,j;
char pre[][7]={
/*运算符之间的优先级制作成一张表格*/
{'>','>','<','<','<','>','>'},
{'>','>','<','<','<','>','>'},
{'>','>','>','>','<','>','>'},
{'>','>','>','>','<','>','>'},
{'<','<','<','<','<','=','0'},
{'>','>','>','>','0','>','>'},
{'<','<','<','<','<','0','='}};
switch(a){
case '+': i=0; break;
case '-': i=1; break;
case '*': i=2; break;
case '/': i=3; break;
case '(': i=4; break;
case ')': i=5; break;
case '#': i=6; break;
}
switch(b){
case '+': j=0; break;
case '-': j=1; break;
case '*': j=2; break;
case '/': j=3; break;
case '(': j=4; break;
case ')': j=5; break;
case '#': j=6; break;
}
return pre[i][j];
}
/*进行实际的运算
*a，b中分别以整数的形式存放两个待运算的操作数
*theta中存放代表操作符的字符
*结果以整数的形式返回
*/
int Operate(int a, char theta, int b){
int i,j,result;
i=a;
j=b;
switch(theta) {
case '+': result = i + j; break;
case '-': result = i - j; break;
case '*': result = i * j; break;
case '/': result = i / j; break;
}
return result;
}
/*从输入缓冲区中获得下一个整数或运算符，并通过n带回到主调函数
*返回值为1表示获得的是运算符
*返回值为0表示获得的是整形操作数
*/
int getNext(int *n){
char c;
*n=0;
while((c=getchar())==' '); /*跳过一个或多个空格*/
if(!isdigit(c)){ /*通过函数判断如果字符不是数字，那么只能是运算符*/
*n=c;
return 1;
}
do { /*能执行到该条语句，说明字符是数字，此处用循环获得连续的数字*/
*n=*n*10+(c-'0'); /*把连续的数字字符转换成相对应的整数*/
c=getchar();
} while(isdigit(c)); /*如果下一个字符是数字，进入下一轮循环*/
ungetc(c,stdin); /*新读入的字符不是数字，可能是运算符,为了不影响下次读入，把该字符放回到输入缓冲区*/
return 0;
}
int EvaluateExpression(){
int n;
int flag;
int c;
char x,theta;
int a,b;
char OP[]="+-*/()#";
SqStack OPTR;
SqStack OPND;
InitStack(&OPTR);
Push(&OPTR,'#');
InitStack(&OPND);
flag=getNext(&c);
GetTop(OPTR, &x);
while(c!='#' || x != '#')
{
if(flag == 0)
{
Push(&OPND,c);
flag = getNext(&c);
} else
{
GetTop(OPTR, &x);
switch(Precede(x, c))
{
case '<'://栈顶元素优先级低
Push(&OPTR,c);
flag = getNext(&c);
break;
case '='://脱括号并接受下一字符
Pop(&OPTR,&x);
flag = getNext(&c);
break;
case '>'：// 退栈并将运算结果入栈
Pop(&OPTR, &theta);
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND, Operate(a, theta, b));
break;
}
}
GetTop(OPTR, &x);
}
GetTop(OPND, &c);
return c;
}
void main(){
int c;
printf("Please input one expression:");
c=EvaluateExpression();
printf("Result=%d\n",c);
getch();
}
⑨ C语言编程（数据结构）:表达式求值
/*在TC2 和 VC6下都可以顺利运行。
做了一个下午。一定要用我这个噢。
有简单的输入错误检测。有完整的说明和
注释*/
#include<stdio.h> /*库文件包含*/
#include<string.h> /*用于字符串操作*/
#include<stdlib.h> /*用于exit函数*/
/**************************************************************************
int check(char *c)
输入参数：
char *c: 输入的字符串
返回参数：
0：字符串中有不符合规定的字符
1: 字符串字符符合规定，没有不符合规定的字符.
功能：
检查字符串中有否除了 0-9, +,-,*,/,(,),之外的其他字符，
如果有，则返回0, 表示出现错误。
若没有，则返回1,表式字符串符合规定。
**************************************************************************/
int check(char *c)
{
int k=0;
while(*c!='\0')
{
if((*c>='0' && *c<='9') || *c=='+' ||
*c=='-' || *c=='*' || *c=='/' ||
*c=='.' || *c=='(' || *c==')' )
{
}
else
{
printf("input error, there have the char not the math expression char!\n");
return 0;
}
if(*c=='(')
k++;
else if(*c==')')
k--;
c++;
}
if(k!=0)
{
printf("input error, there is not have correct bracket '()'!\n");
return 0;
}
return 1;
}
/**************************************************************************
void move(char *f, double *s,int p)
输入参数：
char *f : 运算符数组
double *s: 数值数组
int p: 当前运算符数组位置。
返回参数:
无
功能：
将当前已经完成运算的运算符消去，同时将数值数组的位置调整以进行下一次运算。
传入值p若为3
则当前符号的数组位置为3.
f[3]=f[3+1].......f[len-2]=f[len-1] f[len-1]='\0';
s[i]=s[i+1].......s[len-1]=s[len] 因为数值比运算符多一个。
***************************************************************************/
void move(char *f, double *s,int p)
{
int i=0,len=strlen(f);
for(i=p; i<len; i++) /*将已经运算过的符号，空出来的位置用后面的符号来填充，*/
{ /*即把乘和除号的位置用后面的加和减号填充*/
f[i]=f[i+1];
s[i]=s[i+1];
}
s[i]=s[i+1];
f[len-1]='\0';
}
/**************************************************************************
double convnum(char *c)
输入参数：
char *c :由数字和小数点组成的字符，用以转换成double型的数值。
返回参数：
num:返回转换好的值。
功能：
将输入的字符串先将其小数点以前的部分复制到temp[]数组中，
若有小数点，则将小数点之后的数值，也就是小数部分先进行计算,值存入num中
计算完成后，再对整数部分进行计算，值加上小数部分的值，存入num中。
***************************************************************************/
double convnum(char *c)
{
double num=0.0;
double a=1.0;
int i=0,p=0,len=0;
char temp[100];
int tempi=0;
int start=0;
int f=1; /*正负符号指示器，若为1则为正数，为－1，此数为负数*/
len=strlen&;;
if(c[0]=='-')
{
start=1;
f=-1;
}
for(i=start; i<len; i++)
{
if(c[i]=='.')
{
p=i;
break;
}
temp[tempi++]=c[i]; /*将整数部分复制到temp[]中*/
}
temp[tempi]='\0';
if(p!=0)
{
for(i=p+1;i<len;i++) /*将小数部分计算出来*/
{
if(c[i]=='.') /*如果有多余的小数点，则表示输入错误*/
{
printf("there is more that one dot '.' in number!error!\n");
exit(0);
}
a=a*0.1;
num+=(a*(c[i]-48));
}
}
a=1.0;
len=strlen(temp); /*计算整数部分*/
for(i=len-1;i>=0; i--)
{
num=num+(a*(temp[i]-48));
a*=10;
}
num=num*f;
return num;
}
/**************************************************************************
double good(char *c)
输入参数：
char *c :即将进行运算的字符串型数学表达式。如3.5+(2*3/5)
返回参数：
s[0]:计算结果将放入s[0]中
功能：
将输入的字符串中的数字分别调用convnum(char *c)函数进行数值变换，再将其依
次存入doulbe s[i]中，将加减乘除运算符依次存入字符串符号数组 char f[i]中，
然后如果遇到括号，则将括号内的字符串存入另一字符数组中，然后用此
good(char *c) 递归函数进行递归运算。 然后根据先乘除，后加减的顺序对已
存入数组的数值根 据存入字符串符号数组的运算符进行运算。结果存入s[0]中。
返回最终结果。
***************************************************************************/
double good(char *c) /*可递归函数*/
{ /*取得数值字符串，并调用convnum转换成double*/
char g[100],number[30]; /*g,保存当前的表达式串,number保存一个数的所有字符*/
char f[80]; /*保存所有的符号的堆栈*/
int fi=0; /*保存符号的位置指针*/
double s[80]; /*保存当前所有的数的一个堆栈*/
int si=0; /*保存数字位置指针*/
int k=0; /* 若k=1则表示有一对括号*/
int num=0,i=0; /*num保存新括号内的字符数,i 保存number里的字符位置*/
int cc=0; /*乘除符号数量*/
int jj=0; /*加减符号数量*/
while(*c!='\0')/*当p==1 和k==0时，表示已经把括号里的内容全部复制到g[100]中了*/
{
k=0;
num=0;
switch(*c)
{
case '+': /*当前字符为+-乘除时则表示*/
case '-':
case '*':
case'/':
f[fi++]=*c;
if(*c=='*' || *c=='/')
cc++;
else
jj++;
if(*(c-1)!=')')
{
number[i]='\0';
i=0;/*完成一个数字的复制，其位置指针i=0*/
s[si++]=convnum(number);
}
break;
case'(': /*有括号，则将当前括号作用范围内的全部字符保存，作为*/
k++; /*一个新的字符表达式进行递归调用good函数计算。*/
while(k>0)
{
c++;
g[num]=*c;
num++;
if(*c==')')
{
k--;
}
else if(*c=='(')
{
k++;
}
}
g[num-1]='\0';
num=0;/*完成一个括号内容的复制，其位置指针num=0*/
s[si++]=good(g);
break;
default:
number[i++]=*c;
if(*(c+1)=='\0')
{ number[i]='\0';
s[si++]=convnum(number);
}
break;
}
c++;
}
f[fi]='\0';
i=0;
while(cc>0)
{
switch(f[i])
{
case '*': cc--;
s[i+1]=s[i]*s[i+1];
move(f,s,i);
break;
case '/': cc--;
s[i+1]=s[i]/(float)s[i+1];
move(f,s,i);
break;
default:
i++;
break;
}
}
i=0;
while(jj>0)
{
switch(f[i])
{
case '+': s[i+1]=s[i]+s[i+1];
jj--;
move(f,s,i);
break;
case '-': s[i+1]=s[i]-s[i+1];
jj--;
move(f,s,i);
break;
default:
printf("operator error!");
break;
}
}
return s[0];
}
void main()
{
char str[100];
double sum=0;
int p=1;
while(1)
{
printf("enter expression: enter 'exit' end of program\n");
scanf("%s",str);
p=strcmp(str,"exit");
if(p==0)
break;
p=check(str);
if(p==0)
continue;
sum=good(str);
printf("%s=%f",str,sum);
printf("\n");
}
printf("good bye!\n");
}
例：
enter expression: enter 'exit' end of program
3.5+(12.3*15+8-(3/2+1))*2+(3.2*3-5)/6(输入)
3.5+(12.3*15+8-(3/2+1))*2+(3.2*3-5)/6=384.266667
enter expression: enter 'exit' end of program
china(输入)
input error, there have the char not the math expression char!
enter expression: enter 'exit' end of program
exit(输入)
good bye!
⑩ 《数据结构 课程设计》表达式求值 实验报告
算术表达式求值演示
一、概述
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是算术表达式求值演示。表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。深入了解栈和队列的特性，以便在解决实际问题中灵活运用它们，同时加深对这种结构的理解和认识。
二、 系统分析
1． 以字符列的形式从终端输入语法正确的、不含变量的整数表达式。利用已知的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。
2． 一般来说，计算机解决一个具体问题时，需要经过几个步骤：首先要从具体问题抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编出程序，进行测试，调试直至得到想要的答案。对于算术表达式这个程序，主要利用栈，把运算的先后步骤进行分析并实现简单的运算！为实现算符优先算法，可以使用两个栈，一个用以寄存运算符，另一个用以寄存操作数和运算结果。
3． 演示程序是以用户于计算机的对话方式执行，这需要一个模块来完成使用者与计算机语言的转化。 4． 程序执行时的命令：
本程序为了使用具体，采用菜单式的方式来完成程序的演示，几乎不用输入什么特殊的命令，只需按提示输入表达式即可。（要注意输入时格式，否者可能会引起一些错误） 5. 测试数据。
2
算术表达式求值演示
一、概述
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是算术表达式求值演示。表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。深入了解栈和队列的特性，以便在解决实际问题中灵活运用它们，同时加深对这种结构的理解和认识。
二、 系统分析
1． 以字符列的形式从终端输入语法正确的、不含变量的整数表达式。利用已知的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。
2． 一般来说，计算机解决一个具体问题时，需要经过几个步骤：首先要从具体问题抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编出程序，进行测试，调试直至得到想要的答案。对于算术表达式这个程序，主要利用栈，把运算的先后步骤进行分析并实现简单的运算！为实现算符优先算法，可以使用两个栈，一个用以寄存运算符，另一个用以寄存操作数和运算结果。
3． 演示程序是以用户于计算机的对话方式执行，这需要一个模块来完成使用者与计算机语言的转化。 4． 程序执行时的命令：
本程序为了使用具体，采用菜单式的方式来完成程序的演示，几乎不用输入什么特殊的命令，只需按提示输入表达式即可。（要注意输入时格式，否者可能会引起一些错误） 5. 测试数据。
操作集合：
(1)void InitStack1(SqStack1 &S1);//声明栈建立函数 (2)void InitStack2(SqStack2 &S2);//声明栈建立函数
(3)void evaluate(SqStack1 &S1,SqStack2 &S2);//确定如何入栈函数 (4)void Push1(SqStack1 &S1,char e);//声明入栈函数 (5)void Push2(SqStack2 &S2,float e);//声明入压栈函数 (6)char GetTop1(SqStack1 &S1);//声明取栈顶元素函数 (7)float GetTop2(SqStack2 &S2);//声明取栈顶元素函数 (8)char Pop1(SqStack1 &S1);//声明出栈函数 (9)float Pop2(SqStack2 &S2);//声明出栈函数 (10)char Compare(char m,char n);//声明比较函数
(11)float Operate(float a,char rheta,float b);//声明运算函数 (12)void DispStack1(SqStack1 &S1);//从栈底到栈顶依次输出各元素 (13)void DispStack2(SqStack2 &S2);//从栈底到栈顶依次输出各元素 }ADT SqStack
结构分析:
栈中的数据节点是通过数组来存储的。因为在C语言中数组是用下标从零开始的，因此我
们在调用他们的数据是要特别注意。指针变量的值要么为空(NULL)，不指向任何结点；要么其值为非空，即它的值是一个结点的存储地址。注意，当P为空值时，则它不指向任何结点，此时不能通过P来访问结点，否则会引起程序错误。如果输入的数字不符合题目要求，则会产生错误结果。
算法的时空分析：
时间和空间性能分析：时间上，对于含n个字符的表达式，无论是对其进行合法性检测还是对其进行入栈出栈操作n次，因此其时间复杂度为O(n)。空间上，由于是用数组来存储输入的表达式，用栈来存储运算中的数据和运算符，而栈的本质也用到的数组，数组在定义时必须确定其大小。在不知表达式长度的情况下确定数组的长度确非易事，此时极易造成空间的浪费，因此空间性能不是很好。