王道考研 ++++ 表达式求值（C语言中缀表达式转换为后缀表达式+代码）

最新推荐文章于 2024-08-24 13:34:07 发布

eacapey

最新推荐文章于 2024-08-24 13:34:07 发布

阅读量2.5k

点赞数 6

分类专栏： # 算法

本文链接：https://blog.csdn.net/WX_1218639030/article/details/95863610

版权

算法专栏收录该内容

63 篇文章 0 订阅

订阅专栏

参考博文：https://blog.csdn.net/sgbfblog/article/details/8001651 实现
一、后缀表达式求值

后缀表达式也叫逆波兰表达式，其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为：6 5 2 3 + 8 * + 3 + *，则其求值过程如下：

1）遍历表达式，遇到的数字首先放入栈中，此时栈如下所示：

2）接着读到“+”，则弹出3和2，执行3+2，计算结果等于5，并将5压入到栈中。

3）读到8，将其直接放入栈中。

4）读到“*”，弹出8和5，执行8*5，并将结果40压入栈中。而后过程类似，读到“+”，将40和5弹出，将40+5的结果45压入栈...以此类推。最后求的值288。

二、中缀表达式转后缀表达式

2.1）规则

中缀表达式a + b*c + (d * e + f) * g，其转换成后缀表达式则为a b c * + d e * f + g * +。

转换过程需要用到栈，具体过程如下：

1）如果遇到操作数，我们就直接将其输出。

2）如果遇到操作符，则我们将其放入到栈中，遇到左括号时我们也将其放入栈中。

3）如果遇到一个右括号，则将栈元素弹出，将弹出的操作符输出直到遇到左括号为止。注意，左括号只弹出并不输出。

4）如果遇到任何其他的操作符，如（“+”， “*”，“（”）等，从栈中弹出元素直到遇到发现更低优先级的元素(或者栈为空)为止。弹出完这些元素后，才将遇到的操作符压入到栈中。有一点需要注意，只有在遇到" ) "的情况下我们才弹出" ( "，其他情况我们都不会弹出" ( "。

5）如果我们读到了输入的末尾，则将栈中所有元素依次弹出。

代码：

/*
求值原则
1）如果遇到操作数，我们就直接将其输出。

2）如果遇到操作符，则我们将其放入到栈中，遇到左括号时我们也将其放入栈中。

3）如果遇到一个右括号，则将栈元素弹出，将弹出的操作符输出直到遇到左括号为止。注意，左括号只弹出并不输出。

4）如果遇到任何其他的操作符，优先级高的在上面的话，将其弹出

5）如果我们读到了输入的末尾，则将栈中所有元素依次弹出。
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MaxSize 30
typedef struct
{
  char Stack[MaxSize];
  int top;
}LStack;

typedef struct
{
  char Queue[MaxSize];
  int front,rear;
}LQueue;

/*初始化栈*/
void InitStack(LStack *S)
{
  S->top = -1;
}
/*判断栈是否为空*/
bool JudgeStackEmpty(LStack *S)
{
  if(S->top == -1)return true;
  else return false;
}
/*判断是否栈满*/
bool JudgeStackFull(LStack *S)
{
  if(S->top >= MaxSize)return true;
  else false;
}
/*进栈*/
void EnStack(LStack *S,char ch)
{
  S->Stack[++S->top] = ch;
}
/*判断是否入栈*/
int JudgeEnStack(LStack *S,char ch)
{
  char tp = S->Stack[S->top];
  if(ch >= 'a' && ch <= 'z')return -1;
  else if(ch == '+' && (tp == '+' || tp == '-' || tp == '*' || tp == '/'))return 0;
  else if(ch == '-' && (tp == '+' || tp == '-' || tp == '*' || tp == '/'))return 0;
  else if(ch == '*' && (tp == '*' || tp == '/'))return 0;
  else if(ch == '/' && (tp == '*' || tp == '/'))return 0;
  else if(ch == ')')return 2;
  else return 1;
}
/*出栈*/
char DeStack(LStack *S)
{
  return S->Stack[S->top--];
}
/*初始化队*/
void InitQueue(LQueue *Q)
{
  Q->front = Q->rear = 0;
}
/*入队*/
void EnQueue(LQueue *Q,char ch)
{
  Q->Queue[Q->rear++] = ch;
}
/*出队*/
char DeQueue(LQueue *Q)
{
  return Q->Queue[Q->front++];
}
/*判断队列是否为空*/
bool JudgeQueueEmpety(LQueue *Q)
{
  if(Q->front == Q->rear)return true;
  else return false;
}
int main(int argc, char const *argv[]) {
  LStack S;
  LQueue Q;

  char ch;
  InitStack(&S);
  InitQueue(&Q);

  printf("请输入表达式 # 结束:");
  scanf("%c",&ch);

  while (ch != '#')
  {
    //当栈为空时
    if(JudgeStackEmpty(&S))
    {
      //如果输入的是数即a-z，直接入队
      if(ch >= 'a' && ch <= 'z')Q.Queue[Q.rear++] = ch;
      //如果输入的是运算符，直接入栈
      else EnStack(&S,ch);
    }
    //当栈不为空时
    else
    {
      //返回判断的结果
      int n = JudgeEnStack(&S,ch);
      if(n == -1)//当输入是数字时直接入队
      {
        Q.Queue[Q.rear++] = ch;
      }
      else if(n == 0)//当输入是运算符时企鹅运算符优先级不高于栈头时
      {
        while (1)
        {
          Q.Queue[Q.rear++] = S.Stack[S.top--];//取栈头入队
          n = JudgeEnStack(&S,ch);//再次获取新栈头与输入的运算符比较优先级
          if(n != 0)//当栈头优先级低于输入运算符或者栈头为 ‘）’时
          {
            EnStack(&S,ch);//入栈
            break;
          }
        }
      }else if(n == 2){//当出现’‘)’时 将（）中间的运算符全部 出栈入队
        while (1) {
          char str = DeStack(&S);
          if(str == '(')break;//直到出栈至‘（’
          else Q.Queue[Q.rear++] = str;
        }
      }else{
        EnStack(&S,ch);//无其他情况，直接入队
      }
    }
    scanf("%c",&ch);
  }

  //将最后栈中剩余的运算符 出栈入队
  while (!JudgeStackEmpty(&S)) 
  {
    char str = DeStack(&S);
    EnQueue(&Q,str);
  }

  //输出队中元素
  while (!JudgeQueueEmpety(&Q)) {
    printf("%c ",DeQueue(&Q));
  }

  return 0;
}
//a+b*c+(d*e+f)*g