1. 請問怎麼用c語言編寫四則運算的程序呢
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define size 20
typedef float NUM;
typedef struct
{
NUM data[size];
int top;
}*Space,Lnode;
void begin();
void initialize(Space x,Space y);
void input(Space x,Space y);
int is_operator(char a_operator);
int pushf(Space s,float x);
int pushc(Space s,char x);
int empty(Space s);
int priority(char o);
int popf(Space s,float *x);
int popc(Space s,int *x);
float result(int a_operator,float operand1,float operand2);
main()
{
begin();
system("pause");
}
void begin()
{
Lnode operand,a_operator;//定義兩個指向結構體的指針
Space s_operand=&operand,s_operator=&a_operator;
initialize(s_operand,s_operator);//初始化
input(s_operand,s_operator);//開始
}
void initialize(Space s,Space t)//初始化數據棧、運算符棧
{
s->top=0;
t->top=0;
}
void input(Space x,Space y)
{
int i,j,position=0,op=0;
float operand1=0,operand2=0,evaluate=0;//用來儲存兩個計算數 和 一個結果
char string[50];//所輸入的表達式
char temp[50];//用來臨時存放小數
printf("請輸入表達式: ");
gets(string);
while(string[position]!='\0'&&string[position]!='\n')
{
i=0;
strcpy(temp,"0");
if(is_operator(string[position]))//判斷是否為運算符
{
if(!empty(y))
{
while(!empty(y)&&priority(string[position])<=priority(y->data[y->top-1]))//判斷優先順序
{
popf(x,&operand1);
popf(x,&operand2);
popc(y,&op);
pushf(x,result(op,operand1,operand2));//計算結果
}
}
pushc(y,string[position]);//運算符入棧
position++;
}
while((string[position]!='\0'&&string[position]!='\n')&&(!is_operator(string[position])))//數據存入temp數組
{
temp[i]=string[position];
i++;
position++;
}
pushf(x,atof(temp));//將數組強制轉換為浮點型 然後進行入棧操作 x為指向數據棧的指針 atof函數即使強制轉換類型
}
while(!empty(y))
{
popc(y,&op);
popf(x,&operand1);
popf(x,&operand2);
pushf(x,result(op,operand1,operand2));
}
popf(x,&evaluate);
printf("結果是 : %f",evaluate);
}
int pushf(Space s,float x)//數據入棧
{
if(s->top==size)
return 0;
s->data[s->top]=x;
s->top++;
return 1;
}
int pushc(Space s,char x)//運算符入棧
{
if(s->top==size)
return 0;
s->data[s->top]=x;
s->top++;
return 1;
}
int popf(Space s,float *x)//數據出棧
{
if(s->top==0)
return 0;
else
{
s->top--;
*x=s->data[s->top];
return 1;
}
}
int popc(Space s,int *x)//運算符出棧
{
if(s->top==0)
return 0;
else
{
s->top--;
*x=s->data[s->top];
return 1;
}
}
int empty(Space s)//判斷棧空
{
if(s->top==0)
return 1;
else
return 0;
}
int is_operator(char Operator) //判斷是否為運算符
{
switch(Operator)
{
case '+':
case '-':
case '*':
case '/':
return 1;
default:
return 0;
}
}
int priority(char o) //判斷運算符的優先順序別
{
switch(o)
{
case '+':
case '-':
return 1;
case '*':
case '/':
return 2;
default:
return 0;
}
}
float result(int a_operator,float operand1,float operand2)//計算結果
{
switch(a_operator)
{
case '+':
return operand2+operand1;
case '-':
return operand2-operand1;
case '*':
return operand2*operand1;
case '/':
return operand2/operand1;
}
}
這是用棧寫的 沒有寫輸入錯誤的判斷 你自己添加一下吧
我是因為剛好有一個現成的程序
2. 為什麼用棧實現四則運算
因為棧的「先進後出」。
1，後綴表達式的轉化也能使用棧對中綴表達式進行操作從而轉化。明顯地，由中綴表達式-後綴表達式， 後綴表達式-式子結果。 都需要使用到棧。四則運算有優先順序對吧，比如乘和除都需要先算。
2，如果把符號入棧就可以入一次檢查一次什麼符號，下一個入棧的時候就判斷誰更優先，就出棧進行運算，把這個符號入棧。
3，根據先序，後序，中序，來看入棧和出棧條件，說的簡單，具體還是比較復雜吧。
4，優點就是能判斷優先順序，而非一般的直接從前到後計算。
3. C語言問題,利用堆棧實現四則運算,謝謝高手幫我編寫出來
我就喜歡害人：）
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define ERR -1
#define MAX 100 /*定義堆棧的大小*/
int stack[MAX]; /*用一維數組定義堆棧*/
int top=0; /*定義堆棧指示*/
int push(int i) /*存儲運算數,入棧操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/
return 0;
}
else
{
printf("The stack is full");
return ERR;
}
}
int pop() /*取出運算數，出棧操作*/
{
int var; /*定義待返回的棧頂元素*/
if(top!=NULL) /*堆棧中仍有元素*/
{
var=stack[top--]; /*堆棧指示下移一個位置*/
return var; /*返回棧頂元素*/
}
else
printf("The stack is empty!\n");
return ERR;
}
void main()
{
int m,n;
char l;
int a,b,c;
int k;
do{
printf("\tAriothmatic Operate simulator\n"); /*給出提示信息*/
printf("\n\tPlease input first number:"); /*輸入第一個運算數*/
scanf("%d",&m);
push(m); /*第一個運算數入棧*/
printf("\n\tPlease input second number:"); /*輸入第二個運算數*/
scanf("%d",&n);
push(n); /*第二個運算數入棧*/
printf("\n\tChoose operator(+/-/*//):");
l=getche(); /*輸入運算符*/
switch(l) /*判斷運算符，轉而執行相應代碼*/
{
case '+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):"); /*提示用戶是否結束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}
4. 如何運用大一C語言基礎編寫簡單帶括弧的四則運算
利用堆棧將中綴表達式轉換為後綴表達式計算。簡單給你講一下演算法：
1.從中綴表達式中逐字元讀入操作數
2.若操作數為數字，直接輸出到後綴表達式隊列
3.若操作數為左括弧(，將其壓棧
4.若操作數為加減乘除運算符，將其與棧頂元素比較：
①操作數優先順序高於棧頂元素，則將操作數壓棧；
②操作數優先順序等於或低於棧頂元素，先將棧頂元素出棧，然後將操作數壓棧。
5.若操作數為右括弧)，從棧頂元素開始出棧，直到遇到左括弧(為止，左括弧也出棧。若直到棧底仍然沒有發現左括弧，返回表達式匹配錯誤（說明右括弧過多）
6.表達式讀取完畢，開始將棧中所有剩餘元素出棧。若出棧過程中發現有左括弧，返回表達式匹配錯誤（說明左括弧過多）
除了左括弧以外，所有出棧的元素都進入到後綴表達式隊列中。
7.根據後綴表達式計算算式結果。
5. 用堆棧來實現四則運算.（C語言）
here it is，1個半小時才搞定的，好辛苦，呵呵：
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
double var[1024];
char opt[1024];
double* sp1 = var;
char* sp2 = opt;
#define PUSH(s, v) (*s++ = v)
#define POP(s) (*--s)
#define EMPTY1() (sp1 == var)
#define EMPTY2() (sp2 == opt)
#define TOP(s) (s[-1])
#define isopt1(c) (c == '+' || c == '-')
#define isopt2(c) (c == '*' || c == '/')
#define isopt(c) (isopt1(c) || isopt2(c))
#define isbkt(c) (c == '(')
double docal(double lhs, double rhs, char op)
{
switch(op) {
case '+':return lhs + rhs;
case '-':return lhs - rhs;
case '*':return lhs * rhs;
}
if(op == '/' && rhs == 0) {
printf("divided by zero encountered.\n");
exit(0);
}
return lhs / rhs;
}
void eval1(char* expr)
{
double t1, t2;
while(sp1 - var > 1 && !EMPTY2() && TOP(sp2) != '(') {
t2 = POP(sp1);
t1 = POP(sp1);
PUSH(sp1, docal(t1, t2, POP(sp2)));
}
if(expr)
PUSH(sp2, *expr);
}
void eval2(char* expr)
{
double t1, t2;
while(TOP(sp2) != '(') {
t2 = POP(sp1);
t1 = POP(sp1);
PUSH(sp1, docal(t1, t2, POP(sp2)));
}
POP(sp2);
}
double parse(char* expr)
{
double val;
while(*expr) {
if(isdigit(*expr)) {
sscanf(expr, "%lf", &val);
PUSH(sp1, val);
while(isdigit(*expr) || *expr == '.')
++expr;
--expr;
} else if(isopt(*expr)) {
if(EMPTY2() || (isopt1(TOP(sp2)) && !isopt1(*expr)) || isbkt(TOP(sp2)))
PUSH(sp2, *expr);
else if(isopt(TOP(sp2)))
eval1(expr);
} else if(*expr == '(') {
PUSH(sp2, *expr);
}
6. C語言怎麼實現四則運算
我曾用c編了個計算器,支持四則運算,支持括弧改變優先順序,你看看吧:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define Esc 27
#define Tab 9
void needle(char* s,char* carriage,int start)//needle意為「用針縫」
{
int size_carriage=(int)strlen(carriage);
int i,j;
for(j=0;j<size_carriage;j++)
{
for(i=(int)strlen(s);i>=start;i--)
s[i+1]=s[i];
s[i+1]=carriage[j];
start=i+2;
}
}
double factorial(double d)//factorial意為「階乘」
{
return d==0?1:d*factorial(d-1);
}
void handle(char* carriage)//handle意為「處理」
{
void find_start(char*,int*);
char* save1,*save2,ch;
char op[111];
double d1,d2;
int start,i;
find_start(carriage,&start);
ch=carriage[start];
d1=strtod(carriage,&save1);//strtod是庫函數，功能是將字元串carriage中出現的第一個浮點數轉化為double,並將剩餘字元儲存在save1中
if(ch=='!')
{
sprintf(op,"%g",factorial(d1));//springf是庫函數，功能是將顯示在屏幕上的內容儲存在op中
strcpy(carriage,op);
return;
}
for(i=0;i<(int)strlen(save1);i++)//對於第一個不是'+'或'-'或數字的字元串，strtod無法作用。所以得去掉諸如"*22"字元串中的'*'
save1[i]=save1[i+1];
d2=strtod(save1,&save2);
switch(ch)
{
case '*':sprintf(op,"%.32g",d1*d2);break;
case '/':sprintf(op,"%.32g",d1/d2);break;
case '+':sprintf(op,"%.16g",d1+d2);break;
case '-':sprintf(op,"%.16g",d1-d2);
}
strcpy(carriage,op);
}
void del(char* s,int start,int end)//delete意為「刪除」
{
int i,j;
int size=(int)strlen(s);
for(i=end;i>=start;i--)
for(j=i;j<size;j++)
s[j]=s[j+1];
}
void (char* s,char* carriage,int start,int end)//意為「復制」
{
int i;
for(i=0;start<=end;i++,start++)
carriage[i]=s[start];
carriage[i]='\0';
}
void scissor(char* s,char* carriage,int* start)//scissor意為「用剪刀剪」
{
int sta,end;
for(sta=*start-1;(s[sta]>='0'&&s[sta]<='9')||s[sta]=='.';sta--);
if(sta!=0||s[*start]=='!') //處理式子是-2+3或-2!的特殊情況
sta++;
if(s[*start]=='!')//'!'是單目運算符
end=*start;
else
{
for(end=*start+1;(s[end]>='0'&&s[end]<='9')||s[end]=='.';end++);
if((s[end-1]=='*'||s[end-1]=='/')&&(s[end]=='+'||s[end]=='-'))//處理式子是2*-2等的特殊情況
for(end++;(s[end]>='0'&&s[end]<='9')||s[end]=='.';end++);
end--;
}
(s,carriage,sta,end);
del(s,sta,end);
*start=sta;//記住等下針線函數needle要開始縫的地方
}
void find_start(char* s,int* start)//find_start意為「找到操作符號開始處」
{
int i;
int size=(int)strlen(s);
//由優先順序決定從上而下的順序
for(i=0;i<size;i++)
if(s[i]=='!')
{
*start=i;
return;
}
for(i=0;i<size;i++)
if(s[i]=='*'||s[i]=='/')
{
*start=i;
return;
}
if(s[0]=='+'||s[0]=='-')
{
for(*start=1;(s[*start]>='0'&&s[*start]<='9')||s[*start]=='.';(*start)++);
return;
}
for(i=0;i<size;i++)
if(s[i]=='+'||s[i]=='-')
{
*start=i;
return;
}
}
int judge(char* s)//judge意為「判斷」
{
int i;
int size=(int)strlen(s);
for(i=1;i<size;i++)
if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'||s[i]=='!')
return 1;
return 0;
}
void count(char* s)//count意為「計算」
{
int start,i;
char carriage[555];//carriage意為「運載體」
while(judge(s))//判斷式子是否還需要進行運算
{
for(i=0;i<(int)strlen(s);i++)//此循環作用是將式子中出現的'--'替換為'+'
{
for(;s[i]!='-' && i<(int)strlen(s);i++);//循環結束
if(s[i+1]=='-')
{
del(s,i,i+1);
needle(s,"+",i);
}
}
find_start(s,&start);//讓下標start指向式子應該最先開始處理的運算符
scissor(s,carriage,&start);//用剪刀scissor將start指向的運算符及相對應的操作數剪下並儲存在運載體carriage上
handle(carriage);//處理該運載體，並將運載體上運載的式子的計算結果儲存在運載體上
needle(s,carriage,start);//見函數simplify中的說明
}
}
void simplify(char* s)//simplify意為「簡化」，即將括弧去除
{
char carriage[555];//carriage意為「運載體」
int start,end,i;
int size=(int)strlen(s);
while(1)
{
for(i=0;s[i] != '(' && i<size;i++);//注意這里末尾是分號
if(i==size)
break;//說明式子已不含括弧，簡化完成
for(end=0;s[end] != ')';end++);//使end下標指向式子中第一個出現')'的地方
end--;
for(start=end;s[start] != '(';start--);//尋找與上面一個')'配對的'('
start++;
(s,carriage,start,end);//將括弧里的內容復制給運載體carriage
del(s,start-1,end+1);//刪除整個括弧及其裡面的內容
count(carriage);//計算運載體運載的表達式，運算結果儲存在運載體上
needle(s,carriage,start-1);//將運載體運載過來的結果用針線needle縫在剛才刪除式子s括弧及其內容的地方
}
}
int main()
{
int i=0;
char s[555],ch;
puts(" 本程序不對用戶輸入數據進行檢測:");
puts(" 即用戶應輸入規范的計算式，包括分母不能為0:");
puts(" 式子不能含有空格及其他非計算字元;");
puts(" 按任意一個鍵開始，按回車鍵顯示運算結果;");
while(1)
{
i++;
ch=getch();
if(Esc==ch)
break;
if(Tab==ch)
{
system("cls");//清除當前屏幕
puts("顯示運算結果後：按「Esc」鍵退出,按「Tab」鍵清除當前屏幕");
}
if(i==1)
{
system("cls");
puts("顯示運算結果後：按「Esc」鍵退出,按「Tab」鍵清除當前屏幕");
}
puts("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
gets(s);
simplify(s);
count(s);
puts(s);
//實驗數據：23.243*(5!-23.123/.133+(2!-13/13.23)*(2!-.235)-((4!-20)!/2!)-32*(3!+2.23/(2*3)!))
//其正確結果是：-5953.9401265774754346182917611489
}
puts("謝謝使用!\n有問題可加q問我：281754179");
getch();
return 0;
}
我記得學了數據結構後我又重新用棧寫了個,容錯能力會更好,上面的代碼可以改進很多,也只是給你一個思路罷了
7. C語言字元串四則運算的實現！求指導
以前寫過一個，支持四則運算以及括弧運算，採用棧實現
#include<stdio.h>
#include<malloc.h>
#define null 0
#define max 100
typedef struct date /*定義字元棧*/
{
char sk[max];
int top;
}seqstack;
typedef struct da /*定義數據棧*/
{
int sk[max];
int top;
}stack;
void push(seqstack *s,char x) /*進棧*/
{
if(s->top==max-1)
{
printf("out of space.\n");
}
s->top++;
s->sk[s->top]=x;
}
void spush(stack *s,int x) /*進棧*/
{
if(s->top==max-1)
{
printf("sout of space.\n");
}
s->top++;
s->sk[s->top]=x;
}
char pop(seqstack *s ,char c) /*出棧*/
{
if(s->top==-1)
{
printf("no element.\n");return 0;
}
else
{
c=s->sk[s->top];
s->top--;
return c;
}
}
int spop(stack *s ,int c) /*出棧*/
{
if(s->top==-1)
{
printf("sno element.\n");return 0;
}
else
{
c=s->sk[s->top];
s->top--;
return c;
}
}
int pp(char c) /*判斷字元*/
{
switch(c)
{
case '#':return 0;break;
case '+':return 2;break;
case '-':return 2;break;
case '*':return 3;break;
case '/':return 3;break;
case '(':return 1;break;
case ')':return 4;break;
default:return 9;break;
}
}
int yunsuan(int a,char b,int c) /*運算*/
{
switch(b)
{
case '+':return a+c;break;
case '-':return a-c;break;
case '*':return a*c;break;
default:
if(c==0) return 0; //除數為0
return a/c;break;
}
}
char bijiao(seqstack *f,char c) /*比較優先順序*/
{
int m,n;
char w;
m=pp(c);
w=f->sk[f->top];
n=pp(w);
if(n<m) return '>';
return '<';
}
void main()
{
int x,s;
int q=0,w=0;
int p=0; /*標示變數*/
char ch,th='\0',d='\0';
seqstack *h;
h=(seqstack*)malloc(sizeof(seqstack));
if(!h) printf("no creat");
h->top=-1;
stack *g;
g=(stack*)malloc(sizeof(stack));
if(!g) printf("no door");
g->top=-1;
push(h,'#');
ch=getchar();
while(ch!='\n')
{
if(pp(ch)==9)
{
if(p>0)
{
x=spop(g,x);
spush(g,10*x+ch-48);
}
else
{
spush(g,ch-48);
p++;
}
}
if(pp(ch)==1)
{ push(h,ch);p=0;}
if(pp(ch)==4)
{
while(pp(h->sk[h->top])!=1)
{
q=spop(g,q);
w=spop(g,w);
th=pop(h,th);
spush(g,yunsuan(w,th,q));
}
d=pop(h,d);p=0;
}
if(pp(ch)!=9&&pp(ch)!=1&&pp(ch)!=4)
{
switch(bijiao(h,ch))
{
case '>':push(h,ch);p=0;break;
case '<':
while(pp(h->sk[h->top])>=pp(ch))
{
q=spop(g,q);w=spop(g,w);
th=pop(h,th);
spush(g,yunsuan(w,th,q));
}
push(h,ch); p=0;break;
}
}
ch=getchar();
}
while(ch=='\n'&&h->sk[h->top]!='#')
{
q=spop(g,q);w=spop(g,w);
th=pop(h,th);
s=yunsuan(w,th,q);
spush(g,s);
}
printf("the answer is %d\n",g->sk[g->top]);
}
8. 怎麼用C語言編寫堆棧並能進行四則運算
3個文件，按您的要求
頭文件H
＃IFNDEF _XXXX_H
＃定義_XXXX_H
＃定義錯誤-1
＃定義MAX 100 / *定義堆棧的大小* /
靜態int堆棧[MAX]; / *定義一個一維數組堆棧* /
靜態int top = 0的; / *自定義堆棧指令* /
詮釋推（int i）的;
的pop（）;
＃ENDIF / * _XXXX_H * /
功能文件CPP
＃包括「xxxx.h」的
詮釋推（I）/ *內存操作數棧操作* /
{
？？（頂部<MAX）
？？？
？？？？棧[+ +頂部] = I / *棧，仍然有空間的堆棧頂部的表示移動一個位置* /
？？？？返回0;
？？}
？？其他
？？？
？？？？printf的（「堆棧滿了」）;
？？？？返回錯誤;
？？}
}
POP（）/ *刪除的操作數，並彈出操作* /
{
？？VAR; / *定義要返回的頂級元素* /
？？如果（top! = NULL）/ *仍然堆放元素* /
？？？
？？？？VAR =棧[ - ] / *堆棧指針向下移動一個位置* /
？？？？返回VAR / *返回的頂部堆棧元素* /
？？}
？？其他
？？？？printf的（「堆棧是空的！\ n」）;
？？返回錯誤;
}
主文件CPP
＃包括<stdio.h>
＃包括<conio.h>
＃包括<stdlib.h>
＃包括「xxxx.h」的
無效的主要（）
{
？？INT M，N;
？？字元L;
？？整數A，B，C;
？？整數K;
？？{
？？？？輸出（「\ n \ n \ t單擊以下提示輸入你需要的信息\ n」）;
？？？？輸出（「\ n \問你輸入第二個搗弄數字」）;
？？？？scanf的（「％d」，＆M）;
？？？？推（M）/ *第一個操作數堆棧* /
？？？？輸出（「\ n \問你輸入第二個搗弄數字」）;
？？？？scanf的（「％d」，＆N）;
？？？？推（N）; / *第二個操作數堆棧* /
？？？？輸出（「\ n \你不想算術運算（+ / - / * / /）：」）;
？？？？L = getche（）; / *輸入操作符* /
？？？？開關（L）/ *確定的運營商，依次執行代碼* /
？？？？
？？？？？？'+'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A + B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，' - '：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A-B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，'*'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A * B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？？？情況下，'/'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A / B;
？？？？？？？？輸出（「\ n \ n \ t計算公式為：％d條\ n」，c）;
？？？？？？？？輸出（「\ n」）;
？？？？？？？？;
？？？？}
？？？？輸出（「\ t要繼續輸入計算嗎？（Y / N）：」）; / *提示用戶是否在程序結束* /
？？？？L = getche（）;
？？？？（L =='N'）
？？？？？？退出（0）;
？？}（1）;
}
9. c語言中如何用堆棧實現個位數的四則運算(不帶括弧也可）
#include<iostream>
#include<stdio.h>
#include<math.h>
#define MaxSize 100
using namespace std;
//下面兩個函數不是我發明的，數據結構上有
void trans(char*exp,char postexp[])//此函數是將中綴表達式轉後綴表達式，利用棧
{
char *temp=exp;
for(;*temp!='\0';temp++){if(*temp=='a')*temp='1';}
struct
{
char data[MaxSize];
int top;
}op;
int i=0;
op.top=-1;
while(*exp!='\0')
{
switch(*exp)
{
case '(':
op.top++;op.data[op.top]=*exp;
exp++;
break;
case ')':
while(op.data[op.top]!='(')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top--;
exp++;
break;
case '+':
case '-':
while(op.top!=-1&&op.data[op.top]!='(')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case '*':
case '/':
while(op.data[op.top]=='*'||op.data[op.top]=='/'||op.data[op.top]=='^')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case '^':
while(op.data[op.top]=='^')
{
postexp[i++]=op.data[op.top];
op.top--;
}
op.top++;op.data[op.top]=*exp;
exp++;
break;
case ' '://這里考慮空格了
exp++;
break;
default:
while(*exp>='0'&&*exp<='9')
{
postexp[i++]=*exp;
exp++;
}
postexp[i++]='#';
}
}
while(op.top!=-1)
{
postexp[i++]=op.data[op.top];
op.top--;
}
postexp[i]='\0';
}
float compvalue(char *postexp)//此函數利用棧對後綴表達式求值
{
struct
{
float data[MaxSize];
int top;
}st;
float d,a,b,c;
st.top=-1;
while(*postexp!='\0')
{
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--;
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=pow(b,a);
st.top++;
st.data[st.top]=c;
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]);
}
int main()
{
char exp[50],postexp[50],output[50];
int temp,n;
char *X=output,*Y=exp;//臨時指針
memset(output,0,50);//這句將全部數組元素置為零
memset(exp,0,50);
cout<<"input:"<<endl;
cin.getline(exp,50);
trans(exp,postexp);
temp=compvalue(postexp);
cin>>n;
fflush(stdin);
for(int i=0;i<n;i++)
{
memset(exp,0,50);
cin.getline(exp,50);
trans(exp,postexp);
if(temp==compvalue(postexp)){*X='A'+i;X++;}//通過指針X來逐個向output元素賦值
}
cout<<"output:"<<endl;
cout<<output<<endl;
return 0;
}