william的表达式求值

william的表达式求值

思路
运用两个栈分别存储数字字符和括号，加减乘除等字符，用一个二维数组存储各个数学符号的优先级，需要判断时，用一个函数来调用这个数组来判断优先级，然后进行计算

输入样例1

注：不要加等号哦

输出样例1

输入样例2

输出样例2

以下为源码及部分注释：

/*
--------------------------------
structname : 表达式求值
auther : william
--------------------------------
*/
#include<iostream>
#include<cstring>
#include<stdlib.h> 
#define max 110
using namespace std;  
typedef struct datastack
{
    int data;//储存数据的栈 
	struct datastack *next;	
}datastack;

typedef struct OPND
{
    datastack *top;
}OPND;//其实就是重新命名

typedef struct characterstack
{
	char character;//存储字符数据的栈 比如（） 
	struct characterstack *next; 
}characterstack;

typedef struct OPTR
{
    characterstack *top;
}OPTR;//重新命名

void OPNDinit(OPND *p);
void OPNDpop(OPND * top);
int getstackdata(OPND *top);
void OPNDpush(int data,OPND *top);
void OPTRinit(OPTR *p);
void OPTRpop(OPTR * top);
void OPTRpush(char character,OPTR *top);
char getOPTRtop(OPTR *top);

char PRI[7][7]={ 
    {'>','>','<','<','<','>','>'},  
    {'>','>','<','<','<','>','>'},  
    {'>','>','>','>','<','>','>'},  
    {'>','>','>','>','<','>','>'},  
    {'<','<','<','<','<','=','0'},    
    {'>','>','>','>','0','>','>'},  
    {'<','<','<','<','<','0','='}    //将字符间的优先级存储 横纵坐标分别是 + - * / （ ） # 
	};                                
char judge(char a,char b)
{   
    int i,j;  
    switch(a)
	{  
        case'+':i=0;break;  
        case'-':i=1;break;  
        case'*':i=2;break;  
        case'/':i=3;break;  
        case'(':i=4;break;  
        case')':i=5;break;  
        case'#':i=6;break;    //用函数寻找对应的优先级 
    }  
    switch(b)
	{  
        case'+':j=0;break;  
        case'-':j=1;break;  
        case'*':j=2;break;  
        case'/':j=3;break;  
        case'(':j=4;break;  
        case')':j=5;break;  
        case'#':j=6;break;  
    }  
    return PRI[i][j];  
}
     
int operate(int m,int n,char x)//运算函数，将寻找到的优先级的字符进行运算 
{  
    if(x=='+')
	{  
     return m+n;
    }
    if(x=='-')
	{  
     return n-m;
    }
    if(x=='*')
	{  
     return m*n;
    }
    if(x=='/')
	{  
    return n/m;
    }
}  

int main()
{
    OPND * ND;
    OPTR * TR;
    ND = (OPND *)malloc(sizeof(OPND));
    TR = (OPTR *)malloc(sizeof(OPTR));
    OPNDinit(ND);
    OPTRinit(TR);
    OPTRpush('#',TR);//压入一个“#”判断结束
    char s[max];
    cin>>s;
	char ss[2]="#"; //还存储了一个'\0'; 
    strcat(s,ss);
    char c=s[0]; 
    int k=1;
    while(c!='#'||getOPTRtop(TR)!='#')//还没有到tail
	{ 
        int y=0;  
        if(c>='0'&&c<='9')//如果是数据
        {    
            while(c>='0'&&c<='9')
			{  
                y=y*10+(c-'0');//进位，然后处理成一个数字数据  
                c=s[k++];  
            }  
            OPNDpush(y,ND); //将处理后的数据压栈
        }
        else
		{    
            switch(judge(getOPTRtop(TR),c)) //判断字符栈顶数据的优先级 
            {  
                case'<': 
                    OPTRpush(c,TR);  
                    c=s[k++];  	
                    break;  
                case'=':  
                    OPTRpop(TR); 
                    c=s[k++];  
                    break;  
                case'>':  
                    char x=getOPTRtop(TR);
					OPTRpop(TR);  
                    int m=getstackdata(ND);
					OPNDpop(ND);  
                    int n=getstackdata(ND);
					OPNDpop(ND); 
                    OPNDpush(operate(m,n,x),ND); 
                    break;    
            } 
        }
    }  
    cout<<getstackdata(ND);
    return 0;
}

void OPNDinit(OPND *p)//数据栈的初始化
{
	 p->top= NULL;
}

void OPNDpop(OPND * s)//数据栈的弹出
{
	if(s->top==NULL)
	{
		cout<<"已空"; 
	}
	else
	{
    datastack *temp = s->top;
	s->top = s->top->next;
	free(temp);
    }
}
 
int getstackdata(OPND *s)//得到栈顶的数据
{
    return s->top->data;	
}

void  OPNDpush(int data,OPND *s)//数据的压栈操作
{
     datastack *pt;
	pt = (datastack *)malloc(sizeof(datastack));
	pt->data = data;
	pt->next=s->top;
	s->top = pt;
}
/*
-------------------- 
以上数据栈的函数 
以下字符栈的函数
-------------------- 
*/ 
void OPTRinit(OPTR *p)//字符栈的初始化 
{
	 p ->top = NULL;	   
}

void OPTRpop(OPTR * s)//字符栈的弹栈 
{
		if(s->top==NULL)
	{
		cout<<"已空"; 
	}
	else
	{
    characterstack *temp = s->top;
	s->top = s->top->next;
	free(temp);
    }
}

void OPTRpush(char character,OPTR *s) //字符栈的压栈 
{
     characterstack *pt;
	pt = ( characterstack *)malloc(sizeof( characterstack));//给个空间
	pt->character = character;
	pt->next=s->top;
	s->top = pt;
}

char getOPTRtop(OPTR *s)//得到字符栈的顶部 
{
	return s->top->character;	
}

作业结束。