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.計算