1
回答
数据结构 算数表达式的处理
利用AWS快速构建适用于生产的无服务器应用程序,免费试用12个月>>>   
//seqstack2.h 
#define TRUE 1
#define FALSE 0
#define Stack_Size 50




/*顺序栈-整型*/
typedef struct
{
int elem[Stack_Size];  /*用来存放栈中元素的一维数组*/
int  top;          /*用来存放栈顶元素的下标,top为-1表示栈是空栈*/
}nStack;


/*初始化*/
void  nInitStack(nStack *S)
{
/*构造一个空栈S*/
  S->top=-1;
}


/*判栈空*/
int nIsEmpty(nStack *S) /*判断栈S为空栈时返回值为真,反之为假*/
{
return(S->top==-1?TRUE:FALSE);
}


/*判栈满*/
int nIsFull(nStack *S) /*判断栈S为满栈时返回值为真,反之为假*/
{
return(S->top==Stack_Size-1?TRUE:FALSE);
}


int nPush(nStack * S, int x)
{
if(S->top== Stack_Size-1)  return(FALSE);  /*栈已满*/
S->top++;
S->elem[S->top]=x;
return(TRUE);
}


int nPop(nStack * S, int *x)
{  /* 将栈S的栈顶元素弹出,放到x所指的存储空间中 */
if(S->top==-1)  /*栈为空*/
return(FALSE);
else
{
  *x= S->elem[S->top];
S->top--;    /* 修改栈顶指针 */
  return(TRUE);
}
}


int nGetTop(nStack *S, int *x)
{  /* 将栈S的栈顶元素弹出,放到x所指的存储空间中,但栈顶指针保持不变 */
if(S->top==-1)  /*栈为空*/
return(FALSE);
else
{
  *x = S->elem[S->top];
  return(TRUE);
}
}




/*顺序栈-字符型*/
typedef struct
{
char elem[Stack_Size];  /*用来存放栈中元素的一维数组*/
int  top;          /*用来存放栈顶元素的下标,top为-1表示栈是空栈*/
}strStack;


/*初始化*/
void strInitStack(strStack *S)
{
/*构造一个空栈S*/
  S->top=-1;
}


/*判栈空*/
int strIsEmpty(strStack *S) /*判断栈S为空栈时返回值为真,反之为假*/
{
return(S->top==-1?TRUE:FALSE);
}


/*判栈满*/
int strIsFull(strStack *S) /*判断栈S为满栈时返回值为真,反之为假*/
{
return(S->top==Stack_Size-1?TRUE:FALSE);
}


char strPush(strStack * S, char x)
{
if(S->top== Stack_Size-1)  return(FALSE);  /*栈已满*/
S->top++;
S->elem[S->top]=x;
return(TRUE);
}


char strPop(strStack * S, char *x)
{  /* 将栈S的栈顶元素弹出,放到x所指的存储空间中 */
if(S->top==-1)  /*栈为空*/
return(FALSE);
else
{
  *x= S->elem[S->top];
S->top--;    /* 修改栈顶指针 */
  return(TRUE);
}
}


int strGetTop(strStack *S, char *x)
{  /* 将栈S的栈顶元素弹出,放到x所指的存储空间中,但栈顶指针保持不变 */
if(S->top==-1)  /*栈为空*/
return(FALSE);
else
{
  *x = S->elem[S->top];
  return(TRUE);
}
}


/*功能函数*/
int Match(char ch,char str)
{
if(ch=='('&&str==')')
{
return TRUE;
}
else if(ch=='['&&str==']')
{
return TRUE;
}
else if(ch=='{'&&str=='}')
{
return TRUE;
}
else return FALSE;
}


int In(char ch)
{
if(ch=='+')
{
return TRUE;
}
else if(ch=='-') 
{
return TRUE;
}
else if(ch=='*')
{
return TRUE;
}
else if(ch=='/')
{
return TRUE;
}
else if(ch=='(')
{
return TRUE;
}
else if(ch==')')
{
return TRUE;
}
else if(ch=='#')
{
return TRUE;
}
else return FALSE;
}


char Compare(char x,char ch)//.....
{
switch(x)
{
case '+':
case '-':
if(ch=='+'||ch=='-') return '=';
if(ch=='*'||ch=='/') return '>';
if(ch=='#')          return '<';
case '*':
case '/':
if(ch=='+'||ch=='-') return '<';
if(ch=='*'||ch=='/') return '=';
if(ch=='#')          return '>';
}


}


int Execute(int a,char op,int b)
{
switch(op)
{
case '+':
return (a+b);
break;
case '-':
return (a-b);
break;
case '*':
return (a*b);
break;
case '/':
return (a/b);
break;
}

}

***************

#include "seqstack2.h"
#include "stdio.h"
#include <conio.h>

char ch;

int ExpEvaluation()/*读入一个简单算术表达式并计算其值。operatsign和operatdata分别为运算符栈和运算数栈,OPS为运算符集合*/
{
char x,y;
char op;
int a,b,v;

nStack operatdata;
strStack operatsign;
nInitStack(&operatdata);
strInitStack(&operatsign);
strPush(&operatsign,'#');

printf("\nPlease input an expression (Ending with #) :\n");
    ch=getchar();


 
  strGetTop(&operatsign,&y);

  while(ch!='#'||y!='#') /* strGetTop()通过函数值返回栈顶元素*/
    {
if(!In(ch))                   /*不是运算符,是运算数*/
{

int temp;   /*存放数字的临时变量*/
temp=ch-'0';
/*将字符转换为十进制数*/
fflush(stdin);
ch=getchar();
while(!In(ch))  //用ch逐个读入运算数的各位数码,并转化为十进制数temp
{
temp=temp*10+ch-'0'; // 将逐个读入运算数的各位转化为十进制数
fflush(stdin);
ch=getchar();
}  
    nPush(&operatdata,temp);
}
else
      switch(Compare(y,ch))
{
case '>': 
strPush(&operatsign,ch); 
              fflush(stdin);
ch=getchar();
break;
case '=': //小于和对于的情况 
case '<': 
strPop(&operatsign,&op);
nPop(&operatdata,&b);
nPop(&operatdata,&a);
v=Execute(a,op,b);  /* 对a和b进行op运算 */
nPush(&operatdata,v);
break;
}
strGetTop(&operatsign,&y);
}
nGetTop(&operatdata,&v);
return (v);
}

void main()
{
int result;   
    result=ExpEvaluation();
    printf("\n%d",result);
}
//表达式写完后不会有输出结果

举报
DBZ002
发帖于1年前 1回/110阅
顶部