利用栈进行四则混合运算

#include <iostream>

using namespace std;

#include <string>

#define size2 10

#define size1 100

typedef int iii;

typedef struct

{

char *base;

char *top;

int size;

}stack2;

typedef struct

{

iii * base;

iii* top;

int size;

}stack;

void InitStack(stack2 &s)//初始化栈

{

s.base=(char*)malloc (size1*sizeof(char));

if(!s.base)

{

printf("超出界限\n");

return;

}

else

{

s.top=s.base;

s.size=size1;

}

}

void InitStack(stack &s)//初始化栈

{

s.base=(iii *)malloc (size1*sizeof(iii));

if(!s.base)

{

printf("超出界限\n");

return;

}

else

{

s.top=s.base;

s.size=size1;

}

}

void Insert(stack2 &s ,char a)//插入元素

{

if(s.top-s.base>=s.size)

{

s.base=(char *)realloc
(s.base,(s.size+size1)*sizeof (char));

if(!s.base)

{

printf("超出界限\n");

return
;

}

}

*s.top++=a;

}

void Insert2( stack &s,int a)

{

if(s.top-s.base>=s.size)

{

s.base=(iii *)realloc
(s.base,(s.size+size1)*sizeof (iii));

if(!s.base)

{

printf("超出界限\n");

return
;

}

}

*s.top++=a;

}

char Pop(stack2 &s )//删除栈顶元素，并返回栈顶元素

{

if(s.top==s.base)

{

printf("栈为空\n");

return 'erro';

}

else

{

*--s.top;

return * s.top;

}

}

int Pop2(stack &s)

{

if(s.top==s.base)

{

printf("栈为空\n");

return 'erro';//没意义

}

else

{

*--s.top;

return * s.top;

}

}

void View(stack &s)

{

for(int
i=1;i<=(s.top-s.base);i++)

{

char k;

k=*(s.top-i);

cout<<k<<endl;

}

}

char GetPop(stack2 &s)

{

if(s.top==s.base)

{

printf("栈为空\n");

return-1;

}

else

return *(s.top-1);

}

int GetPop2(stack &s)

{

if(s.top==s.base)

{

printf("栈为空\n");

return-1;

}

else

return *(s.top-1);

}

char Compare(char q,char r)//比较优先级

{

int j[2];

char str[2];

char table[7][7]={

{'>','>','<','<','<','>','>'},

{'>','>','<','<','<','>','>'},

{'>','>','>','>','<','>','>'},

{'>','>','>','>','<','>','>'},

{'<','<','<','<','<','=','e'},

{'>','>','>','>','e','>','>'},

{'<','<','<','<','<','e','='}

};

str[0]=q;

str[1]=r;

for(int i=0;i<2;i++)

{

switch(str[i])

{

case '+':j[i]=0;break;

case '-':j[i]=1;break;

case '*':j[i]=2;break;

case '/':j[i]=3;break;

case '(':j[i]=4;break;

case ')':j[i]=5;break;

case '#':j[i]=6;break;

}

}

return table[j[0]][j[1]];

}

int Operate (int a,char b,int c)

{

switch(b)

{

case '+':

return
a+c;

case '-':

return a-c;

case '*':

return a*c;

case '/':

return a/c;

}

}

bool Decide(char c)

{

if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')

return true;

else

return false;

}

int main()

{

stack2 a;

stack b;//a存储符号，b存储数字

InitStack(a);

Insert(a,'#');

InitStack(b);

char c;

c=getchar();

int temp=0;

while (c!='#'||GetPop(a)!='#')

{

if(!Decide(c))

{

temp=(temp*10+c-'0');//可支持数位数字

c=getchar();

}

else if(Decide(c))

{

if(temp!=0)

{


Insert2(b,temp);

}

temp=0;

switch(Compare(GetPop(a),c))

{

case
'<':

//栈顶元素优先权低

//cout<<"<"<<endl;

Insert(a,c);

c=getchar();

break;

case
'=':

//脱括号

Pop(a);

c=getchar();

break;

case'>':

char
f=Pop(a);

int
g=Pop2(b);

int
h=Pop2(b);

Insert2(b,Operate(h,f,g));

break;

}

}

}

cout<<"结果为"<<endl;

cout<<GetPop2(b)<<endl;

return 0;

}