表达式求值（数据结构）
题目要求：利用栈编写表达式求值程序：输入含有“+”、“-”、“*”、“/”四则运算的表达式，其中负数要用（0-正数）表示，并以=结束。要求输出表达式的值
#include"stdio.h"
#include"stdlib.h"
#include"malloc.h"
#include"string.h"
#include"math.h"
#define OK 1
#define ERROR 0
#define true 1
#define false 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
char OP[8]={'+','-','*','/','(',')','#','^'};

typedef int Status;
typedef char CElemType;
typedef float FElemType;

typedef struct CSqStack
{
    CElemType *base;
    CElemType *top;
    int stacksize;
}CSqStack;
typedef struct FSqStack
{
    FElemType *base;
    FElemType *top;
    int stacksize;
}FSqStack;

Status InitCStack(CSqStack &S)//建立字符栈
{
    S.base=(CElemType *)malloc(STACK_INIT_SIZE*sizeof(CElemType));
    if(!S.base) return ERROR;
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}
Status InitFStack(FSqStack &S)//建立实型栈
{
    S.base=(FElemType *)malloc(STACK_INIT_SIZE*sizeof(FElemType));
    if(!S.base) return ERROR;
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}
Status CPush(CSqStack &S,CElemType e)//插入字符元素
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(CElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(CElemType));
        if(!S.base) return ERROR;
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}
Status FPush(FSqStack &S,FElemType e)//插入实型元素
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(FElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(FElemType));
        if(!S.base) return ERROR;
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}
char CPop(CSqStack &S)//出栈
{
    if(S.base==S.top) return ERROR;
    return *--S.top;
}
char CGetTop(CSqStack S)//返回字符栈的栈顶
{
    if(S.base==S.top) return ERROR;
    return *(S.top-1);
}
float FPop(FSqStack &S)//出栈
{
    if(S.base==S.top) return ERROR;
    return *--S.top;
}
float FGetTop(FSqStack S)//返回实型栈的栈顶
{
    if(S.base==S.top) return ERROR;
    return *(S.top-1);
}

float Operate(float a,unsigned char b,float c)//运算操作
{
    switch(b)
    {
        case'+':return a+c;
        case'-':return a-c;
        case'*':return a*c;
        case'/':return a/c;
        case'^':return pow(a,c);
        default:return 0;
    }

}
Status In(char Test,char *OP)//判断是否属于运算符
{
    int flag=false;
    for(int i=0;i<8;i++)
    {
        if(Test==OP[i]) flag=true;
    }
    return flag;
}

char Precede(char c1,char c2)//优先级比较，并返回比较结果
{
    switch(c1)
    {
        case'+':
        case'-':{
            switch(c2)
            {
                case'+':
                case'-':
                case')':
                case'#':return '>';
                case'*':
                case'/':
                case'(':
                case'^':return '<';
            }
        }
        case'*':
        case'/':{
            switch(c2)
            {
                case'+':
                case'-':
                case'*':
                case'/':
                case')':
                case'#':return '>';
                case'(':
                case'^':return '<';
            }
        }
        case'(':{
            switch(c2)
            {
                case'+':
                case'-':
                case'*':
                case'/':
                case'(':
                case'^':return '<';
                case')':return '=';
            }
        }
        case ')':{
            switch(c2)
            {
                case'+':
                case'-':
                case'*':
                case'/':
                case')':
                case'#':
                case'^':return '>';
            }
        }
        case'#':{
            switch(c2)
            {
                case'+':
                case'-':
                case'*':
                case'/':
                case'(':
                case'^':return '<';
                case'#':return '=';
            }
        }
        case'^':{
            switch(c2)
            {
                case'+':
                case'-':
                case'*':
                case'/':
                case')':
                case'^':
                case'#':return '>';
                case'(':return '<';
            }
        }
    }
    return 0;
}

void EvaluateExpression()
{
    float data,m,n;
    char s[128],s1[128],b[20],a[]={'\0'},d[]={'#','\0'},*p,theta;
    CSqStack OPTR;
    FSqStack OPND;
    InitCStack(OPTR);
    InitFStack(OPND);
    gets(s);//输入字符串
    strncpy(s1,s,strlen(s)-1);//因为题目要求，在表达式后面要加上"="，
    //为避免下面运算麻烦，我将s的前strlen(s)-1个复制到s1中
    CPush(OPTR,'#');//入栈
    p=strcat(s1,d);
    strcpy(b,a);//将b中初始化为'\0'
    while(*p!='#'||CGetTop(OPTR)!='#')
    {
        if(!In(*p,OP))//不是运算符
        {
            d[0]=*p;
            strcat(b,d);p++;
            if(In(*p,OP))
            {
                data=atof(b);//字符串转换为实型
                FPush(OPND,data);//进栈
                strcpy(b,a);//再次使里面为'\0'
            }
        }
        else{
            switch(Precede(CGetTop(OPTR),*p)){
                case'<':CPush(OPTR,*p);p++;break;//栈顶元素优先级低
                case'=':CPop(OPTR);p++;break;//脱括号并接收下一字符
                case'>':theta=CPop(OPTR);//退栈并将运算结果入栈
                        m=FPop(OPND);n=FPop(OPND);
                        FPush(OPND,Operate(n,theta,m));break;

            }

        }
    }
    printf("%.0f",FGetTop(OPND));//输出结果

}
int main()
{
    EvaluateExpression();
    return 0;
}