Ⅰ c語言 後綴表達式計算
while (c!='|')
{
a[i++]=c;
c=exp[k++];
}
//此處再加上a[i]='\0';表示字元串結束看看。
Ⅱ 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 <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iterator>
#include <algorithm>
// 堆棧的數組實現，數組的大小固定。
template<class T>
class stack
{
private:
T *s; // 數組的首地址（棧底）
size_t N; // 指向棧頂第一個空閑塊
const size_t size; // 堆棧的大小，固定不變
public:
stack(size_t n) : size(n)
{
s = new T[n]; // 可能拋出異常
N = 0; // 設置棧頂指針
}
~stack()
{
delete [] s;
}
bool empty() const
{
return N == 0;
}
bool full() const
{
return N == size;
}
void push(const T &object)
{
if (full())
{
throw "error: stack is full !";
}
s[N++] = object;
}
T pop()
{
if (empty())
{
throw "error: stack is empty !";
}
return s[--N];
}
T peek() const
{
if (empty())
{
throw "error: stack is empty !";
}
return s[N-1];
}
friend std::ostream& operator<<(std::ostream& os, const stack<T> &stk)
{
for (size_t i = 0; i < stk.N; i++)
{
std::cout << stk.s[i] << " ";
}
return os;
}
};
// 堆棧的鏈表實現
template<class T>
class STACK
{
private:
typedef struct node
{
T item;
node *next;
node(T x, node *t = NULL) : item(x), next(t) {}
}*link;
link head; // 指向棧頂第一個有效對象
public:
STACK(size_t n)
{
head = NULL;
}
~STACK() // 也可以用pop的方法刪除，但效率低
{
link t = head;
while (t != NULL)
{
link d = t;
t = t->next;
delete d;
}
}
bool empty() const
{
return head == NULL;
}
bool full() const
{
return false;
}
void push(const T &object)
{
head = new node(object, head);
}
T pop()
{
if (empty())
{
throw "error: stack is empty !";
}
T v = head->item;
link t = head->next;
delete head;
head = t;
return v;
}
T peek() const
{
if (empty())
{
throw "error: stack is empty !";
}
return head->item;
}
friend std::ostream& operator<<(std::ostream& os, const STACK<T> &stk)
{
for (link t = stk.head; t != NULL; t = t->next)
{
std::cout << t->item << " ";
}
return os;
}
};
// 中綴表達式轉化為後綴表達式，僅支持加減乘除運算、操作數為1位十進制非負整數的表達式。
char* infix2postfix(const char *infix, char *postfix)
{
const size_t N = strlen(infix);
if (N == 0 || postfix == NULL)
{
return postfix;
}
stack<char> opcode(N); // 堆棧存放的是操作符
for (size_t i = 0; i < N; i++)
{
switch (infix[i])
{
case '(': // 直接忽略左括弧
break;
case ')': // 彈出操作符
*postfix++ = opcode.pop();
*postfix++ = ' ';
break;
case '+':
case '-':
case '*':
case '/':
opcode.push(infix[i]); // 壓入操作符
break;
default:
if (isdigit(infix[i])) // 如果是數字，直接輸出
{
*postfix++ = infix[i];
*postfix++ = ' ';
}
}
}
return postfix;
}
// 後綴表達式轉化為中綴表達式，僅支持加減乘除運算、操作數為1位十進制非負整數的表達式。
char* postfix2infix(const char *postfix, char *infix)
{
const size_t N = strlen(postfix);
if (N == 0 || infix == NULL)
{
return infix;
}
*infix = '\0'; // 初始化輸出字元串為空串
std::vector<std::string> v;
// 初始化，將所有有效字元放入容器
for (size_t i = 0; i < N; i++)
{
if (isdigit(postfix[i]) || postfix[i] == '+'
|| postfix[i] == '-' || postfix[i] == '*' || postfix[i] == '/')
{
v.push_back(std::string(1, postfix[i]));
}
}
// 處理每一個操作符
for (std::vector<std::string>::iterator b = v.begin(); b < v.end(); b++)
{
if (*b == "+" || *b == "-" || *b == "*" || *b == "/")
{
(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
std::cout << "------------------------------------------------" << std::endl;
std::string opcode = *(b);
std::string oprand1 = *(b - 2);
std::string oprand2 = *(b - 1);
b = v.erase(b - 2, b + 1); // 刪除原來的三個表達式，用一個新的表達式替換
b = v.insert(b, std::string("(") + oprand1 + opcode + oprand2 + std::string(")"));
}
}
for (std::vector<std::string>::iterator b = v.begin(); b < v.end(); b++)
{
strcat(infix, (*b).c_str());
}
return infix;
}
// 計算後綴表達式的值，僅支持加減乘除運算、操作數為非負整數的表達式。
int postfix_eval(const char * postfix)
{
const size_t N = strlen(postfix);
if (N == 0)
{
return 0;
}
STACK<int> operand(N); // 堆棧存放的是操作數
for (size_t i = 0 ; i < N; i++)
{
switch (postfix[i])
{
int op1, op2;
case '+':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 + op2);
break;
case '-':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 - op2);
break;
case '*':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 * op2);
break;
case '/':
op1 = operand.pop();
op2 = operand.pop();
operand.push(op1 / op2);
break;
default:
if (isdigit(postfix[i])) // 執行類似atoi()的功能
{
operand.push(0);
while (isdigit(postfix[i]))
{
operand.push(10 * operand.pop() + postfix[i++] - '0');
}
i--;
}
}
std::cout << operand << std::endl; // 輸出堆棧的內容
}
return operand.pop();
}
// 本程序演示了如何後綴表達式和中綴表達式的相互轉換，並利用堆棧計算後綴表達式。
// 轉換方向：org_infix --> postfix --> infix
int main(int argc, const char *argv[])
{
// const char *org_infix = "(5*(((9+8)*(4*6))+7))"; // section 4.3
const char *org_infix = "(5*((9*8)+(7*(4+6))))"; // exercise 4.12
std::cout << "原始中綴表達式：" << org_infix << std::endl;
char *const postfix = new char[strlen(org_infix) + 1];
infix2postfix(org_infix, postfix);
std::cout << "後綴表達式：" << postfix << std::endl;
char *const infix = new char[strlen(postfix) + 1];
postfix2infix(postfix, infix);
std::cout << "中綴表達式：" << infix << std::endl;
std::cout << "計算結果是：" << postfix_eval(postfix) << std::endl;
std::cout << "計算結果是：" << postfix_eval("5 9*8 7 4 6+*2 1 3 * + * + *") << std::endl; // exercise 4.13
delete []infix;
delete []postfix;
return 0;
}
Ⅳ 如何用C語言數據結構的格式實現簡單的算術表達式求值程序
用棧把中綴表達式(輸入的式子）按優先順序轉為後綴表達式（逆波蘭式，即運算符在前，操作數在後），再利用棧變計算邊保存結果用於下一步計算，最後算出式子的答案
以下代碼輸入一個式子（以
=
作為輸入結束標志），輸出結果，負數如-3用0-3表示，支持高位運算
#include
<stdio.h>
#include
<stdlib.h>
#include
<math.h>
#include
<malloc.h>
#define
OK
1
#define
ERROR
-1
typedef
char
SElemType;
typedef
char
Status;
#define
STACK_INIT_SIZE
100000
#define
STACKINCREMENT
2
struct
SqStack
{
SElemType
*base;
SElemType
*top;
int
stacksize;
};
struct
SqStack1
{
int
*base;
int
*top;
int
stacksize;
};
SqStack
OPTR;
SqStack1
OPND;
char
Precede(char
c1,char
c2)
{
if(c1=='+'
||
c1=='-')
{
if(c2=='+'
||
c2=='-'
||
c2==')'
||
c2=='=')
return
'>';
else
return
'<';
}
else
if(c1=='*'
||
c1=='/')
{
if(c2=='(')
return
'<';
else
return
'>';
}
else
if(c1=='(')
{
if(c2==')')
return
'=';
else
return
'<';
}
else
if(c1==')')
return
'>';
else
if(c1=='=')
{
if(c2=='=')
return
'=';
else
return
'<';
}
else
return
'\0';
}
int
In(char
c)
{
if(c=='+'
||
c=='-'
||
c=='*'
||
c=='/'
||
c=='('
||
c==')'
||
c=='=')
return
1;
else
return
0;
}
int
Operrate(int
m,char
b,int
n)
{
switch(b)
{
case
'+':return
m+n;
case
'-':return
m-n;
case
'*':return
m*n;
case
'/':return
m/n;
}
return
0;
}
//操作數
int
InitStack1(SqStack1
&S)
{
S.base=(int
*)malloc(STACK_INIT_SIZE*sizeof(int));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push1(SqStack1
&S,int
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(int
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop1(SqStack1
&S,int
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
int
GetTop1(SqStack1
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
//算符
int
InitStack(SqStack
&S)
{
S.base=(SElemType
*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push(SqStack
&S,SElemType
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop(SqStack
&S,SElemType
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
Status
GetTop(SqStack
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
int
Calculate()
{
char
c,theta,p;
int
a,b,i=0,ans,x;
InitStack(OPTR);
Push(OPTR,'=');
InitStack1(OPND);
c=getchar();
while(c!='='
||
GetTop(OPTR)!='=')
{
if(!In(c)
&&
c>='0'
&&
c<='9')
{
Push1(OPND,c-'0');
c=getchar();
while(c>='0'
&&
c<='9')
{
Pop1(OPND,x);
Push1(OPND,x*10+c-'0');
c=getchar();
}
}
else
if(In(c))
{
switch(Precede(GetTop(OPTR),c))
{
case
'<':
Push(OPTR,c);
c=getchar();
break;
case
'=':
Pop(OPTR,p);
c=getchar();
break;
case
'>':
Pop(OPTR,theta);
Pop1(OPND,b);
Pop1(OPND,a);
ans=Operrate(a,theta,b);
Push1(OPND,ans);
break;
}
}
else
{
c=getchar();
}
}
return
GetTop1(OPND);
}
int
main()
{
int
ans;
ans=Calculate();
printf("%d\n",ans);
return
0;
}
Ⅳ c語言後綴表達式求值詳細程序，可運行的
#include <iostream>
#include <string.h>
using namespace std;
template <class T>
class Stack
{
private:
T *s;
int maxlength;
int top;
public:
Stack(int max)
{
maxlength=max;
s=new T[max];
top=-1;
}
bool isFull()
{
return top==maxlength-1;
}
bool isEmpty()
{
return top==-1;
}
T getTopElement()
{
return s[top];
}
void push(T x)
{
if(isFull())
return;
s[++top]=x;
}
T pop()
{
if(isEmpty())
return '!';
T tmp=s[top];
top--;
return tmp;
}
void clear()
{
top=-1;
}
void traverse()
{
for (int i=0;i<=top;i++)
{
cout<<s[i]<<" ";
}
cout<<endl;
}
};
class Calculator
{
private:
char *f;
int maxlength;
Stack<double> *s;
Stack<char> *t;
int getP(char t)
{
switch(t)
{
case '+':
return 0;
break;
case '-':
return 0;
break;
case '*':
return 1;
break;
case '/':
return 1;
break;
}
return -1;
}
double getResult(char *f)
{
s->clear();
int l=strlen(f);
for(int i=0;i<l;i++)
{
if(f[i]>='0'&&f[i]<='9')
s->push(f[i]-'0');
else
{
double x2=s->pop();
double x1=s->pop();
switch(f[i])
{
case '+':
s->push(x1+x2);
break;
case '-':
s->push(x1-x2);
break;
case '*':
s->push(x1*x2);
break;
case '/':
s->push(x1/x2);
break;
}
}
// s->traverse();
}
double res=s->pop();
return res;
}
public:
Calculator(int max)
{
maxlength=max;
s=new Stack<double>(max);
t=new Stack<char>(max);
}
double run(char *input)
{
char *opt=new char[maxlength];
char *inp=new char[strlen(input)+2];
int cnt=0,l=strlen(input)+2;
for(int i=0;i<l-2;i++)
inp[i]=input[i];
inp[l-2]='#';
inp[l-1]=0;
cout<<inp<<endl;
t->push('#');
for(int i=0;i<l;i++)
{
if(inp[i]>='0'&&inp[i]<='9')
opt[cnt++]=inp[i];
else
{
if(t->getTopElement()=='#' || getP(t->getTopElement())<getP(inp[i]) || inp[i]=='(')
t->push(inp[i]);
else if(inp[i]=='#')
{
while(!t->isEmpty()&&t->getTopElement()!='#')
opt[cnt++]=t->pop();
}
else if(inp[i]==')')
{
while(!t->isEmpty()&&t->getTopElement()!='(')
opt[cnt++]=t->pop();
t->pop();
}
else if(getP(t->getTopElement())>=getP(inp[i]))
{
while(!t->isEmpty()
&&getP(t->getTopElement())>=getP(inp[i])
&&t->getTopElement()!='(')
opt[cnt++]=t->pop();
t->push(inp[i]);
}
}
cout<<"stack:T: ";
t->traverse();
}
opt[cnt]=0;
cout<<opt<<endl;
return getResult(opt);
}
};
int main()
{
Calculator c(30);
int a[2005];
freopen("rpncalc.in","r",stdin);
freopen("rpncalc.out","w",stdout);
cin>>a;
cout<<c.run("a")<<endl;
}
Ⅵ C語言計算表達式的值
逗號運算符
左至右計算
取
表達式
值作
整
語句
值
先算a=3,
a賦值
3
算b=4,
b賦值
4
計算c=a+b
實際
c=3+4
c
值
7
終整條語句
值
c
值7.
Ⅶ 數據結構 後綴法表達式求值C語言編寫
#include<iostream>
usingnamespacestd;
#include<stdio.h>
#include<stdlib.h>
#defineadd43
#definesubs45
#definemult42
#definediv47
#defineMAXSIZE100
typedefstruct
{
intstkdata[MAXSIZE];
inttop;
}STKzone;
typedefSTKzone*STK;
typedefenum{True=1,False=0}boo;
typedefenum{ok,error}status;
STKzoneexpSTKzone;
STKexpSTK;
STKinitSTK(STKzone*stack_zone)
{
stack_zone->top=-1;
returnstack_zone;
}
statuspush(int*term,STKpstk)
{
if(pstk->top==MAXSIZE-1)
returnerror;
pstk->stkdata[++pstk->top]=*term;
returnok;
}/*push*/
boolemptySTK(STKpstk)
{
return(pstk->top==-1);
}
statuspop(int*pdata,STKpstk)
{
if(emptySTK(pstk))
returnerror;
else
{
*pdata=pstk->stkdata[pstk->top];
(pstk->top)--;
returnok;
}
}
voidsynerror()
{
printf(" 表達式語法錯誤！ ");
exit(0);
}
inteval(inta1,inta2,chartag)
{
switch(tag)
{
caseadd:
return(a1+a2);
casesubs:
return(a1-a2);
casemult:
return(a1*a2);
casediv:
return(a1/a2);
}
}
intmain()
{
charc;
intopd1,opd2,temp,c1;
expSTK=initSTK(&expSTKzone);
opd1=1;
opd2=2;
push(&opd1,expSTK);
push(&opd2,expSTK);
printf(" 後綴表達式:");
while((c=getchar())!='/n')
{
if(c=='')continue;
if((c>47)&&(c<58))
{
c1=c-48;
if(push(&c1,expSTK)==error)
{
printf("表達式太長 ");
exit(0);
}
}
elseif((c==add)||(c==subs)||(c==mult)||(c==div))
{
if(pop(&opd1,expSTK)==error)
synerror();
if(pop(&opd2,expSTK)==error)
synerror();
temp=eval(opd1,opd2,c);
push(&temp,expSTK);
}
else{
//你輸入的c是多少，根本就不對
printf("c=[%c],c=%0X ",c,c);
synerror();
}
}/*while*/
if(pop(&temp,expSTK)==error)synerror();
if(!(emptySTK(expSTK)))synerror();
printf("=%-3d ",temp);
return0;
}/*main_end*/
//執行程序看看，你輸入的c值是多少，重新設計一下吧
Ⅷ 誰有c語言的後綴表達式求值
#include<stdio.h>
#define STACKINCREMENT 10
#define stacksize 100
#define OK 1
#define ERROR 0
#define Status char
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}Sqtack;
Status precede(GetTop(OPTR),c)
{
if(GetTop(OPTR)=='+'||GetTop(OPTR)=='-')
if(c=='+'||c=='-'||c==')'||c=='#')
return('>');
else
return('<');
if(GetTop(OPTR)=='*'||GetTop(OPTR)=='/')
if(c=='(')
return('<');
else
return('>');
if(GetTop(OPTR)=='(')
if(c==')')
return('=');
if(c=='#')
return(' ');
else
return('<');
if(GetTop(OPTR)==')')
if(c=='(')
return(' ');
else
return('>');
if(GetTop(OPTR)=='#')
if(c=='#')
return('=');
if(c==')')
return( );
else
return('<');
}
Status In(c,OP)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
return(1);
else
return(0);
}
Status Operate(a,theta,b)
{
status sum,m,n;
m=*a,n=*b;
if(theta=='*')
sum=m*n;
if(theta=='/')
sum=m/n;
if(theta=='+')
sum=m+n;
if(theta=='-')
sum=m-n;
return(sum);
}
OperandType EvaluateExpression()
{
Status a,b,c;
InitStack(OPTR);
push(OPTR,'#' );
Initstack(OPND);
c=getchar();
while(c!='#'||Gettop(OPTR)!='#')
{
if(!In(c,OP)){Push(OPND,c);c=getchar();}
else
swtich(precede(Gettop(OPTR),c))
{case'<':Push(OPTR,c);c=getchar;break;
case'=':Pop(OPTR,x);c=getchar();break;
case'>':Pop(OPTR,theta);Pop(OPND,b);pop(OPND,a);Push(OPND,operate(a,theta,b));break;
}
}
return GetTop(OPND);
}
Status InitStack(SqStack *OPTR)
{
OPTR->base=(SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType ));
if(!OPTR->base) exit (OVERFLOW);
OPTR->top=OPTR->base;
OPTR->stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack *OPTR,SElemType e)
{
if(OPTR->top-OPTR->base>=OPTR->stacksize)
{
OPTR->base=(SElemType *)realloc(OPTR->base,(OPTR->stacksize+STACKINCREMENT)*sizeof(SElemType ));
if(!OPTR->base) exit (OVERFLOW);
OPTR->top=OPTR->base+OPTR->stacksize;
OPTR->stacksize+=STACKINCREMENT;
}
*(OPTR->top)=e;OPTR->top++;
return OK;
}
Status GetTop(SqStack OPTR,SElemType *p)
{
if(OPTR.top==OPTR.base) return ERROR;
*p=*(OPTR.top-1);
return OK;
}
SElemType Pop(SqStack *OPTR)
{
SElemType e;
if(OPTR->top==OPTR->base) return ERROR;
e=*--OPTR->top;
return e;
}
Status InitStack(SqStack *OPND)
{
OPND->base=(SElemType *)malloc(STACK_INIT_SIZE *sizeof(SElemType ));
if(!OPND->base) exit (OVERFLOW);
OPND->top=OPND->base;
OPND->stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack *OPND,SElemType e)
{
if(OPND->top-OPND->base>=OPND->stacksize)
{
OPND->base=(SElemType *)realloc(OPND->base,(OPND->stacksize+STACKINCREMENT)*sizeof(SElemType ));
if(!OPND->base) exit (OVERFLOW);
OPND->top=OPND->base+OPND->stacksize;
OPND->stacksize+=STACKINCREMENT;
}
*(OPND->top)=e;OPND->top++;
return OK;
}
SElemType Pop(SqStack *OPND)
{
SElemType e;
if(OPND->top==OPND->base) return ERROR;
e=*--OPND->top;
return e;
}
main()
{
float result;
EvaluateExpression();
}
Ⅸ c語言數據結構實現後綴表達式求值
維系一個棧，表達式一個指針從前遍歷到最後，是數的話，就壓棧。
是運算的話，就退棧、計算，並將結果壓縮。
計算機算這個很簡單
Ⅹ C語言數據結構：後綴表達式求值
char a[10] = "11+";//字元串自動以'\0'結束