- -|| 忍不住吐槽。。二楼的童鞋写的程序好长啊。。。有必要吗
创新互联专注于企业营销型网站、网站重做改版、翼城网站定制设计、自适应品牌网站建设、H5网站设计、购物商城网站建设、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为翼城等各大城市提供网站开发制作服务。
#includestdio.h
int main()
{
double x,y; // 有除法的题要注意一下，计算机中，整数除法是不准的。。。会省掉余数
printf("please input x"); //所谓的提示句子，我做作业时一般都不写= =!
scanf("%lf",x); //这里要注意一下地是，double型的数据输入用 lf 。我经常习惯性地写 d
printf("Y=5+7(x-6)/9\n"); // 又一句提示，可有可无
y=5+7*(x-6)/9;
printf("%g\n",y);
}
其实用函数去写的话会是整段代码好看些，至少简洁一点。不过我写这么短的代码的时候除非特意练习函数，否则一般都不用的。
我注意看了一下1L，发现输出写错了- -！printf 的实数一律统一 %f 无论是单精度还是双精度
不过我一般习惯用 %g 因为这种输出会省掉后面不必要的零
#include stdlib.h
#include math.h
#include conio.h
#include stdio.h
#include string.h
void SplitPrem(char *str);
float Combine();
char str[200],str1[200],str2[50][30],operate_c[50],sub_str[30];
int operate_2str[50];
int strnum=0,operatenum=0; /* 子字符串个数，操作符个数 */
int i,j,k,flag;
float f=0.0,str_f[50];
void main()
{
float temp;
printf("请输入一个字符串表达式:\n");
gets(str);
strcpy(str1,str);
SplitPrem(str1);
temp=Combine();
printf("%s=%g\n",str,temp);
}
/* 分解为子字符串和操作符 */
void SplitPrem(char *str1)
{
j=strlen(str1);
sub_str[0]=str1[0];
k=1;
for( i=1; ij; i++)
{
if(str1[i]=='*'||str1[i]=='/'||str1[i]=='+'||str1[i]=='-')
{
sub_str[k]=0;
strcpy(str2[strnum],sub_str);
operate_c[operatenum]=str1[i];
operate_2str[operatenum]=strnum;
strnum++;
operatenum++;
k=0;
}
else
{
sub_str[k]=str1[i];
k++;
}
}
if(k0)
{
sub_str[k]=0;
strcpy(str2[strnum],sub_str);
strnum++;
}
for( i=0; istrnum; i++)
str_f[i]=atof(str2[i]); /* 字符串转化为浮点数 */
}
/*先计算乘除，后计算加减，每计算一次，子字符串和操作符向前移动 */
float Combine()
{
while(1)
{
flag=0;
for( i=0; ioperatenum; i++)
{
if(operate_c[i]=='*'||operate_c[i]=='/')
{
if(operate_c[i]=='*')
{
f=str_f[operate_2str[i]]*str_f[operate_2str[i]+1];
str_f[operate_2str[i]]=f;
for( j=i; joperatenum-1; j++)
{
operate_c[j]=operate_c[j+1];
operate_2str[j]=operate_2str[j+1]-1;
}
for( j=operate_2str[i]+1; jstrnum-1; j++)
str_f[j]=str_f[j+1];
operatenum=operatenum-1;
strnum=strnum-1;
flag=1;
}
else
{
f=str_f[operate_2str[i]]/str_f[operate_2str[i]+1];
str_f[operate_2str[i]]=f;
for( j=i; joperatenum-1; j++)
{
operate_c[j]=operate_c[j+1];
operate_2str[j]=operate_2str[j+1]-1;
}
for( j=operate_2str[i]+1; jstrnum-1; j++)
str_f[j]=str_f[j+1];
operatenum=operatenum-1;
strnum=strnum-1;
flag=1;
}
}
}
if(flag==0)break;
}
while(1)
{
flag=0;
for( i=0; ioperatenum; i++)
{
if(operate_c[i]=='+'||operate_c[i]=='-')
{
if(operate_c[i]=='+')
{
f=str_f[operate_2str[i]]+str_f[operate_2str[i]+1];
str_f[operate_2str[i]]=f;
for( j=i; joperatenum-1; j++)
{
operate_c[j]=operate_c[j+1];
operate_2str[j]=operate_2str[j+1]-1;
}
for( j=operate_2str[i]+1; jstrnum-1; j++)
str_f[j]=str_f[j+1];
operatenum=operatenum-1;
strnum=strnum-1;
flag=1;
}
else
{
f=str_f[operate_2str[i]]-str_f[operate_2str[i]+1];
str_f[operate_2str[i]]=f;
for( j=i; joperatenum-1; j++)
{
operate_c[j]=operate_c[j+1];
operate_2str[j]=operate_2str[j+1]-1;
}
for( j=operate_2str[i]+1; jstrnum-1; j++)
str_f[j]=str_f[j+1];
operatenum=operatenum-1;
strnum=strnum-1;
flag=1;
}
}
}
if(flag==0)break;
}
return f;
}
声明一个myCOperate *型指针pOperate，并用strOperateField和调用函数RUNTIME_CLASS(myCOperate)的返回值调用函数etOperate，把函数etOperate的返回值赋给指针pOperate。
#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
#define STACKINCREMENT 2 /* 存储空间分配增量 */
typedef struct SqStack
{
SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */
SElemType *top; /* 栈顶指针 */
int stacksize; /* 当前已分配的存储空间，以元素为单位 */
}SqStack; /* 顺序栈 */
Status InitStack(SqStack *S)
{ /* 构造一个空栈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 GetTop(SqStack S,SElemType *e)
{ /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
if(S.topS.base)
{
*e=*(S.top-1);
return OK;
}
else
return ERROR;
}
Status Push(SqStack *S,SElemType e)
{ /* 插入元素e为新的栈顶元素 */
if((*S).top-(*S).base==(*S).stacksize) /* 栈满 */
return ERROR;
*((*S).top)++=e;
return OK;
}
Status Pop(SqStack *S,SElemType *e)
{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
if((*S).top==(*S).base)
return ERROR;
*e=*--(*S).top;
return OK;
}
#includestdio.h
#includestdlib.h /* atoi() */
#includemath.h
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
/* 表达式求值(范围为int类型,输入负数要用(0-正数)表示) */
typedef int SElemType; /* 栈元素类型为整型,改进算法3.4 */
#include"stack.h"
SElemType Precede(SElemType t1,SElemType t2)
{ /* 根据教科书表3.1，判断两符号的优先关系 */
SElemType f;
switch(t2)
{
case '+':
case '-':if(t1=='('||t1=='=')
f='';
else
f='';
break;
case '*':
case '/':if(t1=='*'||t1=='/'||t1==')')
f='';
else
f='';
break;
case '(':if(t1==')')
{
printf("ERROR1\n");
exit(ERROR);
}
else
f='';
break;
//将此函数补充完整
//......
return f;
}
Status In(SElemType c)
{ /* 判断c是否为运算符 */
switch(c)
{
case'+':
case'-':
//将此函数补充完整
//......
}
}
SElemType Operate(SElemType a,SElemType theta,SElemType b)
{
SElemType c;
switch(theta)
{
case'+':c=a+b;
break;
//将此函数补充完整
//......
}
return c;
}
SElemType EvaluateExpression()
{ /* 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈 */
SqStack OPTR,OPND;
SElemType a,b,d,x,theta;
char c; /* 存放由键盘接收的字符串 */
char z[6]; /* 存放整数字符串 */
int i;
InitStack(OPTR); /* 初始化运算符栈 */
Push(OPTR,'='); /* =是表达式结束标志 */
InitStack(OPND); /* 初始化运算数栈 */
c=getchar();
GetTop(OPTR,x);
while(c!='='||x!='=')
{
if(In(c)) /* 是7种运算符之一 */
switch(Precede(x,c))
{
case'':Push(OPTR,c); /* 栈顶元素优先权低 */
c=getchar();
break;
//将此函数补充完整
//......
}
else if(c='0'c='9') /* c是操作数 */
{
//将此函数补充完整
//......
}
else /* c是非法字符 */
{
printf("ERROR3\n");
exit(ERROR);
}
GetTop(OPTR,x);
}
GetTop(OPND,x);
return x;
}
void main()
{
printf("请输入算术表达式,负数要用(0-正数)表示,并以=结束\n");
printf("%d\n",EvaluateExpression());
}
我这个程序使用了栈这个数据结构,功能是:任意输入一个数学表达式以#结束,可以包括小括号,其他括号不行,我这个程序功能挺强的,可有任意位数,你运行试一下:
//此表达式求值程序功能：运算数可以是任意位数，可以是负数，可以含任意对匹配的括号
//如，-8+3*(-8+23)-12#;另外还有简单的表达式输入错误的判断的功能，
//括号不匹配，运算符多输入或少输入；
#includemalloc.h
#includestdio.h
#define error -1
typedef struct snode1{
int data;
struct snode1*next;
}snode1,*linkstack1;
typedef struct snode2{
char c;
struct snode2*next;
}snode2,*linkstack2;
initstack1(linkstack1*s)
{
*s=(linkstack1)malloc(sizeof(snode1));
(*s)-next=NULL;
}
initstack2(linkstack2*s)
{
*s=(linkstack2)malloc(sizeof(snode2));
(*s)-next=NULL;
}
int popstack1(linkstack1 s)
{
int e;
linkstack1 p;
if(!(s-next))
{ printf("The stack is empty.");return error; }
p=s-next;
e=p-data;
s-next=p-next;
free(p);
return e;
}
pushstack1(linkstack1 s,int x)
{linkstack1 p;
p=(linkstack1)malloc(sizeof(snode1));
p-data=x;
p-next=s-next;
s-next=p;
}
char popstack2(linkstack2 s)
{char e;linkstack2 p;
if(!(s-next))
{
printf("The stack is empty.");return '\0'; }
p=s-next;
e=p-c;
s-next=p-next;
free(p);
return e;
}
pushstack2(linkstack2 s,char x)
{linkstack2 p;
p=(linkstack2)malloc(sizeof(snode2));
p-c=x;
p-next=s-next;
s-next=p;
}
Gettopstack1(linkstack1 s)
{if(!(s-next))
{printf("The stack is empty .");return error;
}
return (s-next-data);
}
char Gettopstack2(linkstack2 s)
{
if(!(s-next))
{printf("The stack is empty .");return '\0';
}
return(s-next-c);
}
char Precede(char c1,char c2)//此函数功能为：比较两运算符的优先级，定义了两个整
{int a,b; //形变量与这两运算符相对应，依据这两优先级，巧妙设置两变量的值
switch(c1) //通过这两整形变量值的大小判定两运算符的优先级
{case'+':
case'-':a=2;break;
case'*':
case'/':a=4;break;
case'#':a=-1;break;
case'(':a=0;break;
case')':a=5;break;
}
switch(c2)
{case'+':
case'-':b=1;break;
case'*':
case'/':b=3;break;
case'#':b=-1;break;
case'(':b=5;break;
case')':b=0;break;
}
if(a==b)return('=');
else if(ab)return('');
else return('');
}
int In(char c)//判定是否是运算符
{ int a;
switch(c)
{case'+':
case'-':
case'*':
case'#':
case'(':
case')':
case'/':a=1;break;
default:a=0;
}
return a;
}
operate(int a,int b,char c)//进行二元运算a@b;
{int x;
switch(c)
{case'+':x=a+b;break;
case'-':x=a-b;break;
case'*':x=a*b;break;
case'/':x=a/b;break;
}
return (x);
}
In2(char ch)//以下这三个函数是判定括号是否匹配
{ int a;
switch(ch)
{case'(':
case'[':
case'{':a=1;break;//这个函数判定是不是括号，左括号还是右括号
case')':
case']':
case'}':a=2;break;
default:a=0;
}
return a;
}
match1(char c1,char c2)//判定这两个括号是不是匹配
{int a;int b;
switch(c1)
{case'(':a=1;break;
case'[':a=2;break;
case'{':a=3;break;
}
switch(c2)
{case')':b=1;break;
case']': b=2;break;
case'}':b=3;break;
}
if(a==b)return 1;
else return 0;
}
match(char*s)
{linkstack2 p;//这是判定整个表达式括号匹配的主导函数，利用了栈这个数据结构
int a ;
initstack2(p);
while(*s)
{a=In2(*s);
if(a==1){pushstack2(p,*s);s++; }
else if(a==2)
{
if(match1(popstack2(p),*s))s++;
else return 0;
}
else s++;
}
if(!(p-next)) return 1;
else return 0;
} //到这里为止
IsRight(char ch1,char ch2)
{
if(In(ch1)In(ch2))
{if(ch2=='('ch1!=')')return 1;
else if(ch1==')'ch2!='(')return 1;
else return 0;
}
else return 1;
}
int EvaluateExpreession()
{char *s,*t,ch;int i=0, sum,a,b,total;
linkstack1 opnd;linkstack2 optr;
initstack1(opnd);
initstack2(optr);pushstack2(optr,'#');
t=(char*)malloc(20*sizeof(char));//为t分配空间
gets(t);//将输入的表达式先保存在字符窜t中
if(!match(t)){printf("syn Erroe!"); return error; }//判定输入的表达式中括号是否匹配，
//如果不的话，输入错误
s=(char*)malloc(30*sizeof(char));//对表达式中的第一个字符进行处理，如果是'－'的话
if(*t=='-')s[i++]='0';//在它前面补0，如果是＋的话，则应将其去掉：这两种不能视为错误
if(*t=='+'(t[1]=='('||!In(t[1])))t++;//应看作视冗余，我们应处理一下
ch=*t;
t++;
while(*t)//下面这个循环功能是：将这样的输入进行处理－－（－2－－－）和（+2－－－）
{ //方法是在负号前补0，将多余的+去除
if(ch=='('*t=='-')
{s[i++]=ch;s[i++]='0';}
else if(ch=='('*t=='+')
{t++;s[i++]=ch;}
else s[i++]=ch;
ch=*t;t++;
}
s[i]=ch;//到这里经过处理后的字符窜都已经存在了s中了
ch=*s++;
while(ch!='#'||Gettopstack2(optr)!='#')//以下为计算的主体部分
{
if(!In(ch))
{ sum=0;
while(!(In(ch)))//如果是数字，则将其放入整形变量sum中，并不断循环，直至
{ //不是数字为止，最后压入栈中，因此这起到了多位数的计算功能
sum=10*sum+ch-48;
if(*s=='#')ch=*s;
else ch=*s++;
}
pushstack1(opnd,sum);
}
// if(!IsRight(ch,*s)){printf("Syn Error!");return error; }
switch(Precede(Gettopstack2(optr),ch))//如果遇到运算符，则将其与栈顶的运算符
{ //进行优先级的比较
case'':pushstack2(optr,ch);ch=*s++;break;//如果栈顶中的低，则将其压入运算符栈中
case'=':popstack2(optr); ch=*s++; break;//如果相等，那么是遇到了左右括号，两都仍掉
case'': //如果栈中高，则进行计算
if(!(opnd-next)){printf("Syn Error!");return;} //如果数栈中竟然没数，则说明表达式输入错误
else b=popstack1(opnd);
if(!(opnd-next)){printf("Syn Error!");return;}
else a=popstack1(opnd);
total=operate(a,b,popstack2(optr));
pushstack1(opnd,total);break;
}
}
if(opnd-next-next){printf("Syn Error!");return;}//运算结束后，数栈中还有两个以上数，则说明表达式错误
printf("biao da shi zhi shi %d ", Gettopstack1(opnd));
}
main()
{
printf("please input the biaodashi:");
EvaluateExpreession();
}
我的能运行!!但表达式末尾加要加#
例如2+3要打2+3#
#includecstdio
#includemalloc.h
#define NULL 0
typedef struct node{
char date;
struct node *next;
}SNode;
SNode *InitStack(){
SNode *top;
top=(SNode *)malloc(sizeof(SNode));
top-next=NULL;
return top;
}
void PushOptr(SNode *top,char x){
SNode *p;
p=(SNode *)malloc(sizeof(SNode));
p-date=x;
p-next=top-next;
top-next=p;
}
char PopOptr(SNode *top){
SNode *p;
char x;
if(top==NULL)
return NULL;
p=top-next;
x=p-date;
top-next=p-next;
free(p);
return x;
}
void PushOpnd(SNode *top,char x){
SNode *p;
p=(SNode *)malloc(sizeof(SNode));
p-date=x;
p-next=top-next;
top-next=p;
}
char PopOpnd(SNode *top){
SNode *p;
char x;
if(top==NULL)
return NULL;
p=top-next;
x=p-date;
top-next=p-next;
free(p);
return x;
}
char GetTop(SNode *top){
return (top-next)-date;
}
int In(char c){
int n;
switch(c){
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
case '#':n=1;break;
default:n=0;break;
}
return n;
}
char Precede(char x,char y){
int i,j;
int form[7][7]={{1,1,-1,-1,-1,1,1},{1,1,-1,-1,-1,1,1},{1,1,1,1,-1,1,1},{1,1,1,1,-1,1,1},{-1,-1,-1,-1,-1,0,2},{1,1,1,1,2,1,1},{-1,-1,-1,-1,-1,2,0}};
switch(x){
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(y){
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;
}
if(form[i][j]==1)
return '';
else
if(form[i][j]==-1)
return '';
else
return '=';
}
int Operate(char x,char z,char y){
int a=x-'0',b=y-'0';
switch(z){
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
}
}
char Eval_Exp(){
char a,b,c,r,f,z;
int result;
SNode *top[2];
top[0]=InitStack();
PushOptr(top[0],'#');
top[1]=InitStack();
c=getchar();
while(c!='#'||(GetTop(top[0]))!='#'){
if(!In(c)){
PushOpnd(top[1],c);
c=getchar();
}
else{
r=Precede(GetTop(top[0]),c);
switch(r){
case '':PushOptr(top[0],c);
c=getchar();
break;
case '=':PopOptr(top[0]);
c=getchar();
break;
case '':b=PopOptr(top[0]);
a=PopOpnd(top[1]);
z=PopOpnd(top[1]);
result=Operate(z,b,a);
f=result+'0';
PushOpnd(top[1],f);
break;
}
}
}
return f;
}
void main(){
char result;
result=Eval_Exp();
printf("%d\n",result-'0');
}