c语言四则运算括号
㈠ 用简单的c语言实现带括号的四则运算
考虑复杂的表达式，不可能简单吧。
#include <stdlib.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
void SplitK(char *str);
void SplitPrem(char *str);
void Combine(float f1,char Operate,float f2);
void StringBracket(char *str);
char str1[100],str2[100],str3[100],sub_str1[100],sub_str2[100],sub_str3[20];
char sub_str31[20],sub_str32[20],str_4[100],operate;
int pause=0,left=0,k1,k2,k3;
float f1=0.0,f2=0.0, f=0.0;
void main()
{
float temp;
printf("Please input a description :\n");
scanf("%s",&str1);
SplitK(str1);
temp=atof(str1);
printf("description value is %.2f\n",temp);
}
void SplitK(char *str)
{
int i,j,k,l,jk;
left=0;
while(*str) {
if(*str == '(') left++;
str++;
}
str2[0]='\0';
str3[0]='\0';
if(left>0)
{
StringBracket(str1);
j=strlen(str1);
for( i=0; i<j; i++)
{
if(str1[i]== '(')
{
jk=0;
for( k=i; k<j; k++)
{
if(str1[k]== ')') break;
for( l=i+1; l<k-1; l++)
{
if(str1[l]== '('){jk++; break;}
}
}
if(jk==0)
{
for(l=0; l<i; l++) str2[l]=str1[l];
str2[i]='\0';
for(l=k+1; l<j; l++) str3[l-k-1]=str1[l];
str3[j-k-1]='\0';
for(l=i+1; l<=k-1; l++) str1[l-i-1]=str1[l];
str1[k-i-1]='\0';
break;
}
}
}
}
SplitPrem(str1);
}
void SplitPrem(char *str)
{
int i,j,k,l;
f1=0.0;
f2=0.0;
pause=0;
strcpy(str1,str);
StringBracket(str1);
j=strlen(str1);
for( i=1; i<j-1; i++)
{
if((str1[i]=='*'||str1[i]=='/'))
{
strcpy(sub_str1," ");
strcpy(sub_str2," ");
strcpy(sub_str3," ");
strcpy(sub_str31," ");
strcpy(sub_str32," ");
operate=str1[i];
for( k1=i-2; k1>=0; k1--)
{
if((str1[k1]=='*'||str1[k1]=='/'||str1[k1]=='+'||str1[k1]=='-'))
{
for( l=0; l<=k1; l++) sub_str1[l]=str1[l];
sub_str1[k1+1]='\0';
break;
}
}
for( k2=i+2; k2<j; k2++)
{
if((str1[k2]=='*'||str1[k2]=='/'||str1[k2]=='+'||str1[k2]=='-'))
{
for(l=k2; l<j; l++) sub_str2[l-k2]=str1[l];
sub_str2[j-k2]='\0';
break;
}
}
if(k1<0) k1=-1;
for(l=k1+1; l<i; l++) sub_str31[l-k1-1]=str1[l];
sub_str31[i-k1-1]='\0';
if(k2>j) k2=j;
for(l=i+1; l<k2; l++) sub_str32[l-i-1]=str1[l];
sub_str32[k2-i-1]='\0';
f1=atof(sub_str31);
f2=atof(sub_str32);
Combine(f1,operate,f2);
}
if(pause==1) break;
}
j=strlen(str1);
for( i=1; i<j-1; i++)
{
if((str1[i]=='+'||str1[i]=='-'))
{
strcpy(sub_str1," ");
strcpy(sub_str2," ");
strcpy(sub_str3," ");
strcpy(sub_str31," ");
strcpy(sub_str32," ");
operate=str1[i];
sub_str1[0]='\0';
k3=0;
for( k2=i+2; k2<j-1; k2++)
{
if((str1[k2]=='+'||str1[k2]=='-'))
{
k3=1;
for(l=k2; l<j; l++) sub_str2[l-k2]=str1[l];
sub_str2[j-k2]='\0';
break;
}
}
for(l=0; l<i; l++) sub_str31[l]=str1[l];
sub_str31[i]='\0';
if(k2>j) k2=j;
if( k3==0) k2=j;
for(l=i+1; l<k2; l++) sub_str32[l-i-1]=str1[l];
sub_str32[k2-i-1]='\0';
f1=atof(sub_str31);
f2=atof(sub_str32);
Combine(f1,operate,f2);
}
if(pause==1) break;
}
strcpy(str_4,str2);
strcat(str_4,str1);
strcat(str_4,str3);
strcpy(str1,str_4);
StringBracket(str1);
j=strlen(str1);
str2[0]='\0';
str3[0]='\0';
for( i=0; i<j; i++)
{
if((str1[i]=='('))
{
SplitK(str1);
break;
}
}
for( i=0; i<j-1; i++)
{
if((str1[i]=='*'||str1[i]=='/'||str1[i]=='+'||str1[i]=='-'))
{
k=1;
if(str1[0]=='-')
{
k=0;
for( l=1; l<j-1; l++)
{
if((str1[l]=='*'||str1[l]=='/'||str1[l]=='+'||str1[l]=='-'))
{
k=1;
break;
}
}
}
if(k==0) break;
if(k==1)
{
SplitPrem(str1);
break;
}
}
}
}
void Combine(float f1,char Operate,float f2)
{
int i,j,k,l;
f=0.0;
switch (Operate) {
case '+':
f=f1+f2;
break;
case '-':
f=f1-f2;
break;
case '*':
f=f1*f2;
break;
case '/':
if(f2!=0)
f=f1/f2;
break;
}
sprintf(sub_str3,"%5.3f",f);
strcpy(str1,sub_str1);
strcat(str1,sub_str3);
strcat(str1,sub_str2);
StringBracket(str1);
j=strlen(str1);
for( i=0; i<j-1; i++)
{
if((str1[i]=='*'||str1[i]=='/'||str1[i]=='+'||str1[i]=='-'))
{
k=1;
if(str1[0]=='-')
{
k=0;
for( l=1; l<j-1; l++)
{
if((str1[l]=='*'||str1[l]=='/'||str1[l]=='+'||str1[l]=='-'))
{
k=1;
break;
}
}
}
if(k==0) break;
if(k==1)
{
SplitPrem(str1);
break;
}
}
}
pause=1;
strcpy(str_4,str2);
strcat(str_4,str1);
strcat(str_4,str3);
strcpy(str1,str_4);
str2[0]='\0';
str3[0]='\0';
StringBracket(str1);
j=strlen(str1);
for( i=0; i<j; i++)
{
if((str1[i]=='('))
{
SplitK(str1);
break;
}
}
}
void StringBracket(char *str)
{
int i,j,len;
len=strlen(str);
j=0;
for(i=0; i<len; i++)
{
if(str[i]!=' ')
{
str[j]=str[i];
j=j+1;
}
}
str[j]='\0';
if(j>0 && str[j-1]=='.')
{
str[j-1]='\0';
j=j-1;
}
}
㈡ 用简单的C语言实现带括号的四则运算
只是吐槽，不负法律责任。
对于四则运算的处理应该属于 AST算法 的一个分支，如果不构建词法分析树的话，就难以对给定串（不一定是简单的四则运算）进行优先级处理。
然而居然能够说出“不用堆栈”之类的话，看样子楼主是基本不会什么数据结构了，即使这样，还奢望能够写出四则运算处理。。
然而语言略微有些偏激了。
简而言之，处理四则运算，考虑优先级规则最简单的方法是堆栈（不考虑优先级的话从左到右扫一遍也是可以的），如果要复杂的方法也行，只是连堆栈都不想用的人，估计理解不了那些复杂方法。
最后一提，如果可以使用数据结构（如栈啊，队列啊）的话，追问可以得到源代码，否则请勿回复，并建议主动关闭问题。
㈢ 求c语言编的四则运算（带括号），要有注释
#include<stdio.h>
#include<stdlib.h>
#define MaxOp 128
#define MaxSize 128
#define Size 128
struct //设定运算符优先级
{
char ch; //运算符
int pri; //优先级
}
lpri[]={{'=',0},{'(',1},{'*',5},{'/',5},{'+',3},{'-',3},{')',6}},
rpri[]={{'=',0},{'(',6},{'*',4},{'/',4},{'+',2},{'-',2},{')',1}};
int leftpri(char op) //求左运算符op的优先级
{
int i;
for(i=0;i<MaxOp;i++)
if(lpri[i].ch==op)
return lpri[i].pri;
}
int rightpri(char op) //求右运算符op的优先级
{
int i;
for(i=0;i<MaxOp;i++)
if(rpri[i].ch==op)
return rpri[i].pri;
}
int InOp(char ch) //判断ch是否为运算符
{
if(ch=='('||ch==')'||ch=='+'||ch=='-'||ch=='*'||ch=='/')
return 1;
else
return 0;
}
int Precede(char op1,char op2) //op1和op2运算符优先级的比较结构
{
if(leftpri(op1)==rightpri(op2))
return 0;
else if(leftpri(op1)<rightpri(op2))
return -1;
else return 1;
}
void trans(char *exp,char postexp[])
//将算术表达式exp转换为后缀表达式postexp
{
struct
{
char data[MaxSize]; //存放运算符
int top; //栈指针
}op; //定义运算符栈
int i=0; //i作为postexp的下标
op.top=-1;
op.top++; //将'='进栈
op.data[op.top]='=';
while(*exp!='\0') //exp表达式未扫描完时循环
{
if(!InOp(*exp)) //为数字字符的情况
{
while(*exp>='0'&&*exp<='9') //判定为数字
{
postexp[i++]=*exp;
exp++;
}
postexp[i++]='#'; //用#标志一个数值串的结束
}
else
switch(Precede(op.data[op.top],*exp))
{
case -1: //栈顶运算符的优先级低
op.top++;op.data[op.top]=*exp;
exp++; //继续扫描其他字符
break;
case 0: // 只有括号满足这种情况
op.top--; //将退栈
exp++;
break;
case 1:
postexp[i++]=op.data[op.top];
op.top--;
break;
}
}
while(op.data[op.top]!='=') //此时exp扫描完毕，退栈到'='为止
{
postexp[i++]=op.data[op.top];
op.top--;
}
postexp[i]='\0'; //给postexp表达式添加结束标志
}
float compvalue(char *postexp) //计算后缀表达式postexp的值
{
struct
{
float data[MaxSize]; //存放数值
int top; //栈指针
}st;
float d,a,b,c;
st.top=-1;
while(*postexp!='\0') //postexp字符串未扫描完时循环
{
switch(*postexp)
{
case '+':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=a+b;
st.top++;
st.data[st.top]=c;
break;
case '-':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=b-a;
st.top++;
st.data[st.top]=c;
break;
case '*':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
c=a*b;
st.top++;
st.data[st.top]=c;
break;
case '/':
a=st.data[st.top];
st.top--;
b=st.data[st.top];
st.top--;
if(a!=0)
{
c=b/a;
st.top++;
st.data[st.top]=c;
}
else
{
printf("\n\t除零错误！ \n");
exit(0);
}
break;
default:
d=0;
while(*postexp>='0'&&*postexp<='9')
{
d=10*d+*postexp-'0';
postexp++;
}
st.top++;
st.data[st.top]=d;
break;
}
postexp++;
}
return(st.data[st.top]);
}
void main()
{
for(;;)
{
char exp[Size];
char postexp[MaxSize];
printf("请输入表达式:");
gets(exp);
trans(exp,postexp);
printf("中缀表达式: %s\n",exp);
printf("后缀表达式: %s\n",postexp);
printf("表达式的值: %g\n",compvalue(postexp));
}
}
㈣ C语言实现带有括号的四则运算
#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
char token[61]; /*存放表达式字符串的数组*/
int n=0;
void error(void) /*报告错误函数*/
{
printf("ERROR!\n");
exit(1);
}
void match(char expected) /*检查字符匹配的函数*/
{
if(token[n]==expected)
token[++n]=getchar();
else error();
}
double term(void); /*计算乘除的函数*/
double factor(void); /*处理括号和数字的函数*/
double exp(void) /*计算加减的函数*/
{
double temp=term();
while((token[n]=='+')||(token[n]=='-'))
switch(token[n])
{
case'+':match('+');
temp+=term();
break;
case'-':match('-');
temp-=term();
break;
}
return temp;
}
double term(void)
{
double div;
double temp=factor();
while((token[n]=='*')||(token[n]=='/'))
switch(token[n])
{
case'*':match('*');
temp*=factor();
break;
case'/':match('/');
div=factor();
if(div==0) /*处理除数为零的情况*/
{
printf("The divisor is zero!\n");
exit(1);
}
temp/=div;
break;
}
return temp;
}
double factor(void)
{
double temp;
char number[61];
int i=0;
if(token[n]=='(')
{
match('(');
temp=exp();
match(')');
}
else if(isdigit(token[n])||token[n]=='.')
{
while(isdigit(token[n])||token[n]=='.') /*将字符串转换为浮点数*/
{
number[i++]=token[n++];
token[n]=getchar();
}
number[i]='\0';
temp=atof(number);
}
else error();
return temp;
}
main()
{
double result;
FILE *data=fopen("61590_4.dat","at");
if(data==NULL)
data=fopen("61590_4.dat","wt");
if(data==NULL)
return 0;
token[n]=getchar();
result=exp();
if(token[n]=='\n')
{
token[n]='\0';
printf("%s=%g\n",token,result);
fprintf(data,"%s=%g\n",token,result);
}
else error();
fclose(data);
return 0;
getch();
}
㈤ 用简单的C语言实现带括号的四则运算
#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!=' ')
{
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! ");
return 0;
}
if(*c=='(')
k++;
else if(*c==')')
k--;
c++;
}
if(k!=0)
{
printf("input error, there is not have correct bracket '()'! ");
return 0;
}
return 1;
}
㈥ C语言实现带有括号的四则运算25.实现带有括号的四则运算【设计要求】输入一个带有括号的四则运算表达
摘要 #include
㈦ 如何运用大一C语言基础编写简单带括号的四则运算
利用堆栈将中缀表达式转换为后缀表达式计算。简单给你讲一下算法：
1.从中缀表达式中逐字符读入操作数
2.若操作数为数字，直接输出到后缀表达式队列
3.若操作数为左括号(，将其压栈
4.若操作数为加减乘除运算符，将其与栈顶元素比较：
①操作数优先级高于栈顶元素，则将操作数压栈；
②操作数优先级等于或低于栈顶元素，先将栈顶元素出栈，然后将操作数压栈。
5.若操作数为右括号)，从栈顶元素开始出栈，直到遇到左括号(为止，左括号也出栈。若直到栈底仍然没有发现左括号，返回表达式匹配错误（说明右括号过多）
6.表达式读取完毕，开始将栈中所有剩余元素出栈。若出栈过程中发现有左括号，返回表达式匹配错误（说明左括号过多）
除了左括号以外，所有出栈的元素都进入到后缀表达式队列中。
7.根据后缀表达式计算算式结果。
㈧ 用c语言编四则运算
用C++写的,用C的话,函数方面很繁琐...
实现不止是整数,小数也可以,但算式中不要有负数,结果中可以有.
2000字不够用,分两部分,前一部分一些全局变量和类的申明:
#include
<iostream.h>
#include
<string.h>
#include
<stdlib.h>
#include
<math.h>
#define
MAX
100
//定义运算优先顺序数组,1表示优先,0表示相等,-1表示非优先,2表示表达式有误
int
com_value[9][9]=
{
1,1,-1,-1,-1,1,1,1,2,
1,1,-1,-1,-1,1,1,1,2,
1,1,1,1,-1,-1,1,1,2,
1,1,1,1,-1,-1,1,1,2,
1,1,1,1,2,-1,1,1,2,
-1,-1,-1,-1,-1,-1,0,2,2,
1,1,1,1,1,2,1,1,2,
-1,-1,-1,-1,-1,-1,2,0,2,
2,2,2,2,2,2,2,2,2
};
//堆栈类模板
template
<class
type>
class
stack
{
public:
stack(){top=new
type[MAX];};
~stack(){};
type
*top;
public:
void
push(type
e){*top=e;top++;}
type
pop(){top--;return*top;}
type
GetTop(){return
*(top-1);}
int
GetTopValue(type
&e)
{
if(e=='+')return
0;else
if(e=='-')return
1;
else
if(e=='*')return
2;else
if(e=='/')return
3;
else
if(e=='^')return
4;else
if(e=='(')return
5;
else
if(e==')')return
6;else
if(e=='=')return
7;
else
return
8;
}
int
GetTopValue()
{
type
temp=GetTop();
if(temp=='+')return
0;else
if(temp=='-')return
1;
else
if(temp=='*')return
2;else
if(temp=='/')return
3;
else
if(temp=='^')return
4;else
if(temp=='(')return
5;
else
if(temp==')')return
6;else
if(temp=='=')return
7;
else
return
8;
}
type
calculate(char
s)
{
type
b=pop(),a=pop();
if(s=='+')return
a+b;
if(s=='-')return
a-b;
if(s=='*')return
a*b;
if(s=='/')return
a/b;
if(s=='^')return
pow(a,b);
}
};
㈨ 用C语言编写带括号的四则运算
#include <stdio.h>
#include "windows.h"
main()
{
char Exp[1024]={0},Oper[100]={0};
int Num[200]={0},Expi=0,Operi=0,Numi=0;
boolean isnum=FALSE;
printf("input a Expression:");
scanf("%s",Exp);
while(Exp[Expi]!='\0')
{
switch(Exp[Expi]) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
Num[Numi]=Num[Numi]*10+Exp[Expi]-'0';
isnum=TRUE;
break;
}
case '+':
case '-':
{
if(isnum) //又录入一个新数据
{
Numi++;
isnum=FALSE;
}
while(Operi!=0&&Oper[Operi-1]!='(')
{
if(Operi<1||Numi<2)
{
printf("Expression is error!\n");
exit(0);
}
switch(Oper[Operi-1]) {
case '+':
Num[Numi-2]=Num[Numi-2]+Num[Numi-1];
Num[Numi-1]=0;
Numi--;
Oper[Operi-1]='\0';
Operi--;
break;
case '-':
Num[Numi-2]=Num[Numi-2]-Num[Numi-1];
Num[Numi-1]=0;
Numi--;
Oper[Operi-1]='\0';
Operi--;
break;
case '*':
Num[Numi-2]=Num[Numi-2]*Num[Numi-1];
Num[Numi-1]=0;
Numi--;
Oper[Operi-1]='\0';
Operi--;
break;
case '/':
Num[Numi-2]=Num[Numi-2]/Num[Numi-1];
Num[Numi-1]=0;
Numi--;
Oper[Operi-1]='\0';
Operi--;
break;
}
}
Oper[Operi]=Exp[Expi];
Operi++;
break;
}
㈩ 如何使用c语言实现四则运算，详细思路很重要啊（越详细越好~），可以木有代码（急）
1.判断四则运算字符串的括号是否匹配，可以用以个栈来计算，开始栈是空，从头遍历所有字符，找到'('，压栈，找到')'弹出一个元素，遍历完成以后如果栈是空表示正常，非空，或则中间出现问题都表示括号不正常。
2.分解四则运算中的所有元素，把所有分解的元素放在队列中，遍历整个字符串，有switch分支，如果是0-9的字符用一个字符串存储并和前面的字符组合起来，如果是'+''-''*''/'就把前面存储数字的字符串当成一个元素放进队列，并把当前运算法符当成一个元素也放进队列，遍历完成以后所有的数据和运算符都分开了，比如234+456，会分解成234，+，456三个元素。
3.然后分解队列，用两个栈，一个存放所有元素用A表示，一个存放运算符号用B表示（这个是临时变量），从头开始遍历整个队列，如果是数据就把数据压到A栈。如果元素是运算符就分开处理，如果是'(''+''-''*''/'')'处理方法都不一样，详细说明太复杂，整体的思想就是把数据和运算符的顺序排列好（上面的元素排列以后变成234,456，+；可以参考后序排列）。
4.计算：依次弹出A中的元素，如果是数据把数据压在栈C中，如果是运算符，从C中弹出该运算符需要的数据，然后把计算结果再次压进栈C，当A遍历完以后，C顶元素就是计算结果。
整个大题思路：1.检查，2.分解，3.中序排列，4.后序排列，5.计算