后缀中缀表达式

#include "stdio.h"
#include "conio.h"
#include "string.h"
#include "stdlib.h"
#define null 0
typedef struct node
{char item[20];
 struct node *next;}node,*stack;//定义链式堆栈元素类型以及堆栈类型

typedef struct queuenode
{char item[20];
 struct queuenode *next;}queuenode;//定义链式队列元素类型
typedef struct
{queuenode *front;
 queuenode *rear;}queue;//定义链队列类型

void createstack(stack &s) //创建一个空堆栈（不带头结点的链栈）
{s=null;
}

int stackempty(stack s) //判断堆栈是否为空
{
  if(s==null)  return 1;
 else  return 0;}

node *makenode(char *item) //创建一个堆栈结点,并使其数据域等于item
{
 node *pnode;
 pnode=(node *)malloc(sizeof(node));
 if(!pnode) exit(0);
 else
  {strcpy(pnode->item,item);  pnode->next=null;}
 return pnode;}

void push(stack &s,char *item)//压栈
{
 node *pnode=makenode(item);
 pnode->next=s;
 s=pnode;}

void pop(stack &s,char *item)//出栈
{
 node *pnode;
 if(!stackempty(s))
 {pnode=s;
  strcpy(item,pnode->item);
  s=pnode->next;
  free(pnode);}
}

void clearstack(stack &s)//清空堆栈
{
 node *pnode;
 while(!stackempty(s))
 {pnode=s;
   s=pnode->next;
  free(pnode);}
}

int stacksize(stack s)//计算栈中结点的个数
{int i=0;
 node *pnode;
 if(!stackempty(s))
 {for(pnode=s;!pnode; pnode=pnode->next) i++;}
 return i;
}

void stacktop(stack s,char *item)//取栈顶元素，但不把栈顶元素出栈
{

 if(!stackempty(s))
 {
  strcpy(item,s->item);}

}

queuenode *makequeuenode(char *item)//创建一个链队列结点，并使其数据域等于item
{
 queuenode *pnode;
 pnode=(queuenode *)malloc(sizeof(queuenode));
 if(pnode==null)
    exit(0);
 else
 {
  strcpy(pnode->item,item);
  pnode->next=null;}
 return pnode;
}

 void createqueue(queue &q) //创建一个空队列，不带头结点
{

  q.front=q.rear=null;

}


int queueempty(queue q)//判断一个队列是否为空
{
 if(q.front==null)
    return 1;
 else
   return 0;
}

void queueinsert(queue &q,char *item)//入队
{
 queuenode *pnode=makequeuenode(item);
 if(queueempty(q))
   q.front=q.rear=pnode;
 else
 {
  q.rear->next=pnode; q.rear=pnode;}
}

void queuedel(queue &q,char *item)//出队
{
 queuenode *pnode;
 if(queueempty(q)) printf("出队错误，队列为空！\n");
 else
 {
 pnode=q.front;strcpy(item,pnode->item);q.front=pnode->next;free(pnode);}
}

int queuesize(queue q)//求队列长度
{int i=0;
 queuenode *pnode;
 if(!queueempty(q))
 {for(pnode=q.front;!pnode; pnode=pnode->next) i++;}
 return i;
}

void clearqueue(queue &q)//清空队列
{ queuenode *pnode;
 while(!queueempty(q))
 {pnode=q.front;q.front=pnode->next; free(pnode);}

}

void queuefront(queue q,char *item)//取队头元素，但并不出队
{

 if(!queueempty(q))

 {
 strcpy(item,q.front->item);}
}

void printqueue(queue q)//输出队列中的元素
{ queuenode *pnode;
 if(!queueempty(q))
 {printf("\n队列元素：");pnode=q.front;
  while(pnode){printf("%s ,",pnode->item); pnode=pnode->next;}
 }
}

void printstack(stack s)//输出堆栈中的元素
{ node *pnode;
 if(!stackempty(s))
 {printf("\n堆栈元素：");pnode=s;
  while(pnode){printf("%s ,",pnode->item); pnode=pnode->next;}
 }
}

int priorty(char opr)//求运算符号优先级
{switch(opr)
 {case '(': return 0;
  case '-': return 1;
  case '+': return 1;
  case '*': return 2;
  case '/': return 2;
 }
}

void caculate(queue q)//计算后缀表达式的数值，要求最初参与运算的数值是整数
{
 char temp[20],opr[20],num[20];
 double fa,fb;
 stack stack_num;
 createstack(stack_num);
 while(!queueempty(q))
 {
  queuedel(q,opr);
  if((opr[0]>='0'&&opr[0]<='9')||(opr[0]=='.'))
  push(stack_num,opr);
  else
  {
   pop(stack_num,num);
   fb=atof(num);
   pop(stack_num,num);
   fa=atof(num);
   switch(opr[0])
 {case '+':fa+=fb;break;
  case '-':fa-=fb;break;
  case '*': fa*=fb;break;
  case '/': if(fb==0){printf("\n除0出错！");exit(0);}
	       else {fa/=fb;break;}
 }  sprintf(num,"%f",fa); push(stack_num,num);

   }
 }pop(stack_num,num); printf("\n运算结果是：%s",num);
}

//括号匹配检查
int kuohao(char x[200])
{
    char s[200];
    int l=0;
    int length=strlen(x);
    for(int i=0;i<length;i++){
        if(x[i]=='('||x[i]==')') s[l++]=x[i];
    }
    if(l&1) return 0;
    else if(s[0]==']'||s[0]==')'||s[l-1]=='('||s[l-1]=='[') return 0;
    else
    {
        int leftb=0,rightb=0,left=0,right=0;
        for(int i=0;i<l;i++)
        {
            if(s[i]=='[')
            left++;
            else if(s[i]=='(')
            leftb++;
            else if(s[i]==']')
            right++;
            else
            rightb++;
        }
        int x=0;
        if(strstr(s,"(]")||strstr(s,"[)"))
            x=1;
        if(x==0&&leftb==rightb&&left==right)
            return 1;
        else return 0;
    }
}

//后缀表达式计算
void houzui(char s[200])
{
    char Num[200];
    int t=0;
    bool flag=false;
    int len=strlen(s);
    double S[200];
    int tot=0;
    for(int i=0;i<=len;i++)
    {
        if(s[i]>='0'&&s[i]<='9')
        {
            Num[t++]=s[i];
            flag=true;
        }
        else if(s[i]==' '||s[i]=='\0')
        {
            if(flag)
            {
                Num[t]='\0';
                S[++tot]=atof(Num);
                t=0;
                flag=false;
            }
        }
        else
        {
            double b=S[tot];tot--;//两数位置和前缀不一样
            double a=S[tot];tot--;
            double c;
            switch(s[i])
            {
                case '+':c=a+b;break;
                case '-':c=a-b;break;
                case '*':c=a*b;break;
                case '/':c=a/b;
            }
            S[++tot]=c;
        }
    }
    printf("%lf\n", S[tot]);
}

int main()
{
 char sexpression[200],temp[20],opr[20];
 int i,j,isnum;
 stack stack_opr;
 queue queue_exp;
printf("-------------------欢迎使用-------------------\n");
printf("按要求输入操作：\n");
printf("1：进行后缀式计算操作!\n");
printf("2：进行中缀式计算操作!\n");
printf("0: 退出程序！\n");
int comp;
scanf("%d",&comp);
getchar();
if(comp==0) return 0;
 if(comp==1){
    printf("\n请输入待计算的表达式（后缀式）：\n");
 gets(sexpression);
 printf("%s\n",sexpression);
  if(!kuohao(sexpression)){
    printf("括号不匹配！重新输入！\n");
    return 0;
 }
 houzui(sexpression);
 return 0;
 }
 printf("\n请输入待计算的表达式（中缀式）：\n");
 gets(sexpression);
 printf("%s\n",sexpression);
 if(!kuohao(sexpression)){
    printf("括号不匹配！重新输入！\n");
    return 0;
 }
 createstack(stack_opr);
 createqueue(queue_exp);
 i=0;
 while(sexpression[i]!='\0')
  {
   isnum=j=0;
   while(sexpression[i]>='0'&&sexpression[i]<='9')
    {isnum=1;temp[j++]=sexpression[i++];}
   if(isnum){temp[j]='\0';queueinsert(queue_exp,temp);}
   else {temp[0]=sexpression[i++];temp[1]='\0';
         switch(temp[0])
         {case '(':push(stack_opr,temp);break;
          case '+':
          case '-':
          case '*':
          case '/': if(!stackempty(stack_opr))
                    while(priorty(temp[0])<=priorty(stack_opr->item[0]))
                     {pop(stack_opr,opr);queueinsert(queue_exp,opr);if(stackempty(stack_opr)) break;}
                    push(stack_opr,temp);
                    break;
         case ')': while(stack_opr->item[0]!='(')
                     {pop(stack_opr,opr); queueinsert(queue_exp,opr);}
                    pop(stack_opr,opr);
                    break;
         } }
  printstack(stack_opr);//可以注释掉，加上是为了看堆栈内元素的变化
  printqueue(queue_exp);//可以注释掉，加上是为了看队列内元素的变化
  }
 while(!stackempty(stack_opr)) {pop(stack_opr,opr);queueinsert(queue_exp,opr);}
 printqueue(queue_exp);//这次队列中所有的元素就是转换好的后缀表达式
 caculate(queue_exp);
 printstack(stack_opr);//输出计算结果
 getch();
 }