#define OK 1
#define SElemType int
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OVERFLOW 0
#define ERROR 0
#define TRUE 1
#define FALSE 0
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
typedef bool Status;
typedef int OperandType;
char optr[]={'+','-','*','/','(',')','='};

char prece[]={
'+','>','>','<','<','<','>','>',
'-','>','>','<','<','<','>','>',
'*','>','>','>','>','<','>','>',
'/','>','>','>','>','<','>','>',
'(','<','<','<','<','<','=',' ',
')','>','>','>','>',' ','>','>',
'=','<','<','<','<','<',' ','='};

typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;

typedef struct{
    char *base;
    char *top;
    int stacksize;
}ptr;

Status StackEmpty(SqStack S)
{
    if(S.top==S.base)return TRUE;
    return FALSE;
}

Status ptrStackEmpty(ptr S)
{
    if(S.top==S.base)return TRUE;
    return FALSE;
}


Status DestroyStack(SqStack &S)
{
    SElemType *temp;
    while(S.top!=S.base)
    {
        temp=S.top;
        free(temp);
        S.top--;
    }
    free(S.top);
    S.stacksize=0;
    return TRUE;
}

Status ClearStack(SqStack &S)
{
    SElemType *temp;
    while(S.top!=S.base)
    {
        *S.top--=0;
    }
    *S.top=0;
    return TRUE;
}

SElemType GetTop(SqStack S)
{
    SElemType e;
    if(S.top==S.base)return ERROR;
    e=*(S.top-1);
    return e;
}

char ptrGetTop(ptr S)
{
    char e;
    if(S.top==S.base)return ERROR;
    e=*(S.top-1);
    return e;
}

Status InitStack(SqStack &S)
{
    S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base)exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}

Status ptrInitStack(ptr &S)
{
    S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));
    if(!S.base)exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}

Status Push(SqStack &S,SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base)exit(OVERFLOW);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}

Status ptrPush(ptr &S,char e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(char *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));
        if(!S.base)exit(OVERFLOW);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return OK;
}

Status Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base)return ERROR;
    e=*--S.top;
    return OK;
}

Status ptrPop(ptr &S,char &e)
{
    if(S.top==S.base)return ERROR;
    e=*--S.top;
    return OK;
}

Status IsOPTR(char c,int &j)
{
    int i;
    for(i=0;i<7;i++)
    {
        if(c==optr[i])break;
    }
    if(i<7)
    {
        j=i;
        return TRUE;
    }
    else return FALSE;
}

char Precede(char a,char c)
{
    int b1,b2;
    char b;
    if(IsOPTR(a,b1)&&IsOPTR(c,b2))
    {
        b=prece[b1*8+b2+1];
        return b;   
    }
    return 0;
}

OperandType Operate(int a,char theta,int b)
{
    int c;
    if(theta=='+')
    c=a+b;
    else if(theta=='-')
    c=a-b;
    else if(theta=='*')
    c=a*b;
    else if(theta=='/')
    c=a/b;
    return c;
}

OperandType EvaluateExpression(ptr &OPTR,SqStack &OPND){
    int OP;
    char c,theta,x;
    int a,b;
    ptrInitStack(OPTR);ptrPush(OPTR,'=');
    InitStack(OPND);c=getchar();
    while(!ptrStackEmpty(OPTR))
    {
        
        if(!IsOPTR(c,OP))
        {
            a=0;
            while(!IsOPTR(c,OP))
            {
            if(c==' ')
            {
                c=getchar();
                continue;
            }
            else if(isdigit(c))
            {
                a=a*10+c-'0';
            }
            c=getchar();
            }
            Push(OPND,a);   
        }
        else
        {
            switch (Precede(ptrGetTop(OPTR),c))
            {
                case '<':ptrPush(OPTR,c);c=getchar();break;
                case '=':ptrPop(OPTR,x);c=getchar();break;
                case '>':ptrPop(OPTR,theta);Pop(OPND,b);Pop(OPND,a);Push(OPND,Operate(a,theta,b));break;
            }
        }
        
    }
    return GetTop(OPND);
}

main()
{
    SqStack OPND;
    ptr OPTR;
    int a;
    a=EvaluateExpression(OPTR,OPND);
    printf("\n运算结果为%d",a);
   
}

看上去很简单的样子~

太复杂了脑子要烧的。

#define TRUE 1
#define FALSE 0
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
typedef bool Status;

你都能用bool类型，为什么要多此一举定义两个宏？

PS：加上浮点运算为什么会很复杂？

[此贴子已经被作者于2017-6-22 19:21编辑过]

没想那么多，感觉直接用true，false,函数比较清晰。
另外加浮点运算是不是要用重载，这个不大会？自己定义了两个栈不晓得用一个行不行？

c里自带关键字true false 都是小写

基本思想是把中缀表达式转化为后缀表达式~通过两个符号的优先级进行比较~如果后者的优先级大于前这则入符号栈~否则出栈~至于浮点数~感觉就是对小数进行判断那里要多弄些代码~在原基础上改改应该可以的~

以前这个程序没有消化好，今天又看了下，那个和优先级有点区别，它确定算式中什么应该先算，算好的放在数字栈中，并没有把中缀变为后缀。
至于那个表是在书上抄的。