用堆栈实现算术表达式的运算，可是输入算术表达式之后回车就没反应了

[qq459673705]

//SeqStack.h
typedef struct stack
{
DATA data[SIZE+1];
int top;
}Seqstack;

Seqstack* SeqstackInit()
{
Seqstack* q;
if(!(q=(Seqstack*)malloc(sizeof(Seqstack))))
{
printf("分配内存失败!\n");
return NULL;
}
else
q->top=0;
return q;
}

int SeqstackIsEmpty(Seqstack* p)
{
return(p->top==0);//这里少了一个等号
}
void SeqstackFree(Seqstack* p)
{
if(p)
{
free(p);
}
}
void SeqstackClear(Seqstack* p)
{
p->top=0;
}

int SeqstackIsFull(Seqstack* p)
{
return(p->top==SIZE);
}

int SeqstackPush(Seqstack* p,DATA data)
{
if(p->top+1>SIZE)
{
printf("堆栈溢出\n");
return 0;
}
else
p->data[++p->top]=data;
return 1;
}
DATA SeqstackPop(Seqstack* p)
{
if(p->top==0)
{
printf("堆栈已空\n");
exit(0);
}
return (p->data[p->top--]);
}
DATA Seqstackpeek(Seqstack* p)
{
if(SeqstackIsEmpty(p))
{
printf("堆栈已空\n");
exit(0);
}
return(p->data[p->top]);
}
//calcexp.c
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define SIZE 50
typedef int DATA;
#include "SeqStack.h"
int IsOperator(char c)
{
switch(c)
{
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
case '=':
return 1;
break;
defualt:
return 0;
break;
}
}
int PRI(char oper1,char oper2)
{
int pri;
switch(oper2)
{
case '+':
case '-':
if(oper1=='('||oper1=='=')
pri=-1;
else
pri=1;
break;
case '*':
case '/':
if(oper1=='*'||oper1=='/'||oper1==')')
pri=1;
else
pri=-1;
break;
case '(':
if(oper1==')')
{
printf("语法错误!\n");
exit(0);
}
else
pri=-1;
break;
case ')':
if(oper1=='(')
pri=0;
else if(oper1=='=')
{
printf("括号比匹配\n");
exit(0);
}
else
pri=1;
break;
case '=':
if(oper1=='(')
{
printf("括号不匹配\n");
exit(0);
}
else if(oper1=='=')
pri=0;
else
pri=1;
break;//少了这个可是麻烦事
}
return pri;
}
int Calc(int a,int oper,int b)
{
switch(oper)
{
case '+': return a+b;
case '-': return a-b;
case '*': return a*b;
case '/':
if(b!=0)
{
return a/b;
}
else
{
printf("除0溢出!\n");
exit(0);
}
}
}

int CalcExp(char exp[])
{
Seqstack *stackOper,*stackdata;
int i=0,flag=0;
DATA a,b,c,q,x,t,oper;

stackOper=SeqstackInit();
stackdata=SeqstackInit();

q=0;
x='=';
SeqstackPush(stackOper,x);
x=Seqstackpeek(stackOper);
c=exp[i++];
while(c!='='||x!='=')
{
if(IsOperator(c))
{
if(flag)
{
SeqstackPush(stackdata,q);
q=0;
flag=0;//别少了这一步
}
switch(PRI(x,c))
{
case -1:
SeqstackPush(stackOper,c);
c=exp[i++];
break;
case 0:
SeqstackPop(stackOper);
c=exp[i++];
break;
case 1:
oper=SeqstackPop(stackOper);
b=SeqstackPop(stackdata);
a=SeqstackPop(stackdata);
t=Calc(a,oper,b);
SeqstackPush(stackdata,t);
break;
}
}
else if(c>='0'&&c<='9')
{
c-='0';
q=q*10+c;
flag=1;
c=exp[i++];
}
else
{
printf("输入错误!\n");
getch();
exit(0);
}
x=Seqstackpeek(stackOper);
}
q=SeqstackPop(stackdata);
SeqstackFree(stackOper);
SeqstackFree(stackdata);
return q;
}
int main()
{
int c;
char exp[80];
printf("请输入算术表达式（以=结尾）:!\n");
scanf("%s",exp);
printf("%s%d\n",exp,CalcExp(exp));

return 0;
}

[無_1024]

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h> 
#define STACK_INIT_SIZE 200//存储空间初始分配量
#define STACKINCREMENT  100//存储空间分配增量
typedef float SElemType;
typedef struct sqstack
{
    SElemType *base;
    SElemType *top;
    int stacksize;
}*SqStack;
void InitStack(SqStack s)//构造栈
{
    s->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!s->base)
    {
        printf("OVERFLOW!!");
        exit(1);
    }
    s->top=s->base;
    s->stacksize=STACK_INIT_SIZE;
}
void GetTop(SqStack s,SElemType *e)//读取栈顶元素
{
    if(s->top==s->base)
    {
        printf("The Stack Is Empty!!\n");
        exit(1);
    }
    *e=*(s->top-1);
}
void 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)
        {
            printf("The Stack Is Empty!!\n");
            exit(1);
        }
        s->top=s->base+s->stacksize;
        s->stacksize+=STACKINCREMENT;
    }
    *(s->top)=e;
    s->top++;
}
void Pop(SqStack s,SElemType *e)//删除栈顶元素
{
    if(s->top==s->base)
    {
        printf("The Stack Is Empty!!\n");
        exit(1);
    }
    *e=*(--s->top);
}
int In(char e)//判断是否为7种运算符之一
{
    switch(e)
    {
    case '+':
    case '-':
    case '*':
    case '/':
    case '(':
    case ')':
    case '#':return(1);break;//是运算符返回 1，否则，返回 0
    default:return(0);
    }
}
char Precede(char p,char c)//比较OPTR栈顶元素与取得元素的优先级
{                          //栈顶元素优先级高，返回 '>'，反之返回 '<'
    switch(p)
    {
    case '+':
    case '-':
        switch(c)
        {
        case '*':
        case '/':
        case '(':return '<';break;
        default:return '>';break;
        }
        break;
    case '*':
    case '/':
        switch(c)
        {
        case '(':return '<';break;
        default:return '>';break;
        }
        break;
    case '(':
        switch(c)
        {
        case ')':return '=';break;
        case '#':printf("ERROR!!\n");exit(1);
        default:return '<';break;
        }
        break;
    case ')':
        switch(c)
        {
        case '(':printf("ERROR!!\n");exit(1);
        default:return '>';break;
        }
        break;
    case '#':
        switch(c)
        {
        case ')':printf("ERROR!!\n");exit(1);
        case '#':return '=';break;
        default:return '<';break;
        }
        break;
    }
}
SElemType Operate(SElemType x,char n,SElemType y)//四则运算
{
    SElemType e;
    switch(n)
    {
    case '+':e=x+y;break;
    case '-':e=x-y;break;
    case '*':e=x*y;break;
    case '/':
        if(y==0)//分母不能为 0
        {
            printf("The Denominator MUST NOT BE ZERO!!!\n");
            exit(1);
        }
        else
        {
            e=x/y;
            break;
        }
    }
    return e;
}
int main()
{
    SqStack OPTR,OPND;//定义运算符存储栈OPTR，数据存储栈OPND
    SElemType p,s,a,b,theta;
    char c,*str;//str存储逆波兰表达式
    int flag,decimal_place,strsize=STACK_INIT_SIZE,num=0,i=0;//flag记录运算数是否为小数(是=1,否=0)
                                                             //decimal_place记录运算数的小数位数
                                                             //strsize记录str的大小
    OPTR=(SqStack)malloc(sizeof(SqStack));//分配空间
    OPND=(SqStack)malloc(sizeof(SqStack));
    str=(char *)malloc(STACK_INIT_SIZE*sizeof(char));
    printf("Please Input The Expression Ending With '#'\n(Only including +-*/ and non-negative Real Numbers):\n");
    InitStack(OPTR);//创建运算符存储栈
    Push(OPTR,'#');
    InitStack(OPND);//创建数据存储栈
    c=getchar();
    GetTop(OPTR,&p);//p为栈顶元素
    while(c!='#'||p!='#')
    {
        if(!In(c))//不是运算符，存入数据栈
        {
            if(num>=strsize)//为str增加空间
            {
                str=(char *)realloc(str,(strsize+STACKINCREMENT)*sizeof(char));
                strsize=strsize+STACKINCREMENT;
            }
            str[num++]=c;
            flag=0;
            decimal_place=0;
            s=c-48;//字符与数字转换
            c=getchar();
            while(c>='0'&&c<='9'||c=='.')
            {
                if(num>=strsize)
                {
                    str=(char *)realloc(str,(strsize+STACKINCREMENT)*sizeof(char));
                    strsize=strsize+STACKINCREMENT;
                }
                str[num++]=c;
                if(c=='.')
                {
                    flag=1;
                    c=getchar();
                    continue;
                }
                if(flag==1)decimal_place++;
                s=s*10+(c-48);
                c=getchar();
            }
            if(num>=strsize)
            {
                str=(char *)realloc(str,(strsize+STACKINCREMENT)*sizeof(char));
                strsize=strsize+STACKINCREMENT;
            }
            str[num++]='#';
            s=s/pow(10,decimal_place);
            Push(OPND,s);
        }
        else
        {
            switch(Precede(p,c))
            {
            case '<':Push(OPTR,c);//栈顶元素优先级低，将c存入栈
                c=getchar();break;
            case '=':Pop(OPTR,&s);//两者优先级相同，脱去括号
                c=getchar();break;
            case '>':Pop(OPTR,&theta);//栈顶元素优先级高，取出OPTR中运算符theta，取出OPND中两数据a,b，用c运算，将结果存入OPND
                Pop(OPND,&b);Pop(OPND,&a);
                Push(OPND,Operate(a,theta,b));
                if(num>=strsize)
                {
                    str=(char *)realloc(str,(strsize+STACKINCREMENT)*sizeof(char));
                    strsize=strsize+STACKINCREMENT;
                }
                str[num++]=theta;
                str[num++]='#';
                break;
            }
            GetTop(OPTR,&p);
        }        
    }//while
    printf("\n");
    printf("The Reverse Polish Notation is:\n");
    while(i<num)//输出逆波兰表达式
    {
        if(str[i]=='#')printf(" ");
        else printf("%c",str[i]);
        i++;
    }
    printf("\n\n");
    GetTop(OPND,&p);
    printf("Answer is:%f\n",p);
    getch();
}

这儿有一个自己看吧 你的贴的太乱了
注意这儿有模块的可以很好的贴代码

[bdmh]

看着都晕，想帮你调试吧，还却数据类型，自己跟踪吧，跟踪到哪出问题，问题很容易就解决了

[jixingzhong]

可以参考一下这个：
http://wenku.baidu.com/view/0679d60f76c66137ee06198f.html

[Dora]

[qq459673705]

windows下调试了半天没弄出结果，只得在linux下用gdb试着调试，结果一下子便找到了问题，
其实也就是default写成了defualt，
结果弄了一整天