表达式求值问题

最新推荐文章于 2024-10-08 21:25:49 发布
最新推荐文章于 2024-10-08 21:25:49 发布
阅读量1.6w 收藏 46
点赞数 11
分类专栏： 数据结构和算法 编程语言学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccf19881030/article/details/8220776
版权

    最近在学习表达式求值问题，想使用C++或C语言实现一个带圆括号的十进制正整数的表达式求值控制台程序。这个问题可以通过栈或者二叉树遍历来解决。记得以前在学校学习数据结构中栈的应用时看到过，另外编译原理这门课也有讲过。重新翻开<<数据结构-C语言描述 耿国华 主编>>一书的P80~P83第3张有关栈相应的章节时，有一个无括号算术表达式的求值问题，其次在对应的光盘上课程设计里头有表达式求值的相关描述，这里记录如下：

[问题描述]
一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正整数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。引入表达式起始、结束符是为了方便。编程利用“算符优先法”求算术表达式的值。

[基本要求]
（1） 从键盘读入一个合法的算术表达式，输出正确的结果。
（2） 显示输入序列和栈的变化过程。

[选作内容]
（1） 扩充运算符集合。
（2） 引入变量操作数。
（3） 操作数类型扩充到实数

 

相应的C语言代码如下：

//expression.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <conio.h>

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

char ops[7]={'+','-','*','/','(',')','#'};  /*运算符数组*/

int  cmp[7][7]={{2,2,1,1,1,2,2},    /*用来进行比较运算符优先级的矩阵,3代表'=',2代表'>',1代表'<',0代表不可比*/
                {2,2,1,1,1,2,2},
                {2,2,2,2,1,2,2},
                {2,2,2,2,1,2,2},
                {1,1,1,1,1,3,0},
                {2,2,2,2,0,2,2},
                {1,1,1,1,1,0,3}};

typedef struct
{ 
	char elem[Stack_Size];
	int top;
}SeqStack;     /*运算符栈的定义*/

typedef struct
{
	int elem[Stack_Size];
	int top;
}nSeqStack;   /* 运算数栈的定义*/


void InitStack(SeqStack *S)   /*初始化运算符栈*/
{
	S->top =-1;
}

void InitStackn(nSeqStack *S)   /*初始化运算数栈*/
{
	S->top =-1;
}

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

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

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

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

int Push(SeqStack *S, char x)   /*运算符栈入栈函数*/
{
	if (S->top==Stack_Size-1)
	{
		printf("Stack is full!\n");
		return FALSE;
	}
	else
	{
		S->top++;
		S->elem[S->top]=x;
		return TRUE;
	}
}

int Pushn(nSeqStack *S, int x)   /*运算数栈入栈函数*/
{
	if (S->top==Stack_Size-1)
	{
		printf("Stack is full!\n");
		return FALSE;
	}
	else
	{
		S->top++;
		S->elem[S->top]=x;
		return TRUE;
	}
}
 
int Pop(SeqStack *S, char *x)    /*运算符栈出栈函数*/
{
	if (S->top==-1)
	{
		printf("运算符栈空!\n");
		return FALSE;
	}
	else
	{
		*x=S->elem[S->top];
		S->top--;
		return TRUE;
	}
}
 
int Popn(nSeqStack *S, int *x)    /*运算数栈出栈函数*/
{
	if (S->top==-1)
	{
		printf("运算符栈空!\n");
		return FALSE;
	}
	else
	{
		*x=S->elem[S->top];
		S->top--;
		return TRUE;
	}
}

char GetTop(SeqStack *S)    /*运算符栈取栈顶元素函数*/     
{
	if (S->top ==-1)
	{
		printf("运算符栈为空!\n");
		return FALSE;
	}
	else
	{
		return (S->elem[S->top]);
	}
}

int GetTopn(nSeqStack *S)    /*运算数栈取栈顶元素函数*/     
{
	if (S->top ==-1)
	{
		printf("运算符栈为空!\n");
		return FALSE;
	}
	else
	{
		return (S->elem[S->top]);
	}
}


int Isoperator(char ch)        /*判断输入字符是否为运算符函数,是返回TRUE,不是返回FALSE*/
{
	int i;
	for (i=0;i<7;i++)
	{
		if(ch==ops[i])
			return TRUE;
	}
	return FALSE;
}

/*
int isvariable(char ch)
{ if (ch>='a'&&ch<='z')
      return true;
   else 
	   return false;
}*/


char Compare(char ch1, char ch2)   /*比较运算符优先级函数*/
{
	int i,m,n;
	char pri;                     /*保存优先级比较后的结果'>'、'<'、'='*/
	int priority;                 /*优先级比较矩阵中的结果*/  
	for(i=0;i<7;i++)              /*找到相比较的两个运算符在比较矩阵里的相对位置*/
	{
		if(ch1==ops[i])	
			m=i;
		if (ch2==ops[i])
			n=i;
	}

	priority = cmp[m][n];
	switch(priority)
	{
	case 1:
		pri='<';
		break;
	case 2:
		pri='>';
		break;
	case 3:
		pri='=';
		break;
	case 0:
		pri='$';
		printf("表达式错误!\n");
		break;
	}
	return pri;
}
	
int Execute(int a, char op, int b)    /*运算函数*/
{
	int result;
	switch(op)
	{
	case '+':
		result=a+b;
		break;
	case '-':
		result=a-b;
		break;
	case '*':
		result=a*b;
		break;
	case '/':
		result=a/b;
		break;
	}
    return result;
}

int ExpEvaluation() 
/*读入一个简单算术表达式并计算其值。optr和operand分别为运算符栈和运算数栈，OPS为运算符集合*/
{
	int a,b,v,temp;
	char ch,op;
	char *str;
	int i=0;
	
	SeqStack optr;                                   /*运算符栈*/
	nSeqStack operand;                               /*运算数栈*/

	InitStack(&optr);
	InitStackn(&operand);
	Push(&optr,'#');
	printf("请输入表达式(以#结束):\n");            /*表达式输入*/
	str =(char *)malloc(50*sizeof(char));
	gets(str);                                     /*取得一行表达式至字符串中*/

	ch=str[i];
	i++;
	while(ch!='#'||GetTop(&optr)!='#')
	{ 
		if(!Isoperator(ch))
		{
			temp=ch-'0';    /*将字符转换为十进制数*/
			ch=str[i];
			i++;
			while(!Isoperator(ch))
			{
				temp=temp*10 + ch-'0'; /*将逐个读入运算数的各位转化为十进制数*/
				ch=str[i];
				i++;
			}
			Pushn(&operand,temp);
		}
		else
		{
			switch(Compare(GetTop(&optr),ch))
			{
			case '<':
				Push(&optr,ch); 
				ch=str[i];
				i++;
				break;
			case '=':
				Pop(&optr,&op);
				ch=str[i];
				i++;
				break;
			case '>':
				Pop(&optr,&op);
				Popn(&operand,&b);
				Popn(&operand,&a);
				v=Execute(a,op,b);  /* 对a和b进行op运算 */
				Pushn(&operand,v);
				break;
			}
		}		
	}
	v=GetTopn(&operand);
	return v;
}

void main()                               /*主函数*/
{
	int result;
	result=ExpEvaluation();
	printf("\n表达式结果是%d\n",result);
}

 

 

 这其中有几个难点：

1、运算符优先级矩阵的设计，里面的运算符优先级如何比较，里面我觉得涉及到编译原理的知识。

2、使用栈求表达式的值

在开源中国的代码分享中看到了一篇用栈实现表达式求值的一篇文章，作者网名为路伟，网址为：http://www.oschina.net/code/snippet_818195_15722，现在引述如下，算作借鉴吧。

作者用栈ADT实现了，表达式求值问题。
用户输入表达式以字符串形式接收，然后处理计算最后求出值
目前仅支持运算符 '(' , ')' , '+' , '-', '*' , '/' 的表达式求值。
内附源代码和一个可执行程序，无图形界面

代码如下：

//ElemType.h
 
/***
 *ElemType.h - ElemType的定义
 *
 ****/
 
#ifndef ELEMTYPE_H
 #define ELEMTYPE_H
 
// 定义包含int和float的共同体
 typedef union ET{
  float fElem;
  char cElem;
 }ET;
 
typedef ET ElemType;
 
//int  compare(ElemType x, ElemType y);
 void visit(ElemType e);
 
#endif /* ELEMTYPE_H */
 
//mainTest.cpp
 
/**
  *
  * 文件名称：mainTest.cpp
  * 摘    要：利用 ADT-栈 完成表达式求值，表达式求值相关函数定义
  **/
 
#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include "DynaSeqStack.h"
 
// 表达式的最大长度
 #define MAX_EXPRESSION_LENGTH 100
 // 操作数的最大值
 #define MAX_OPERAND_LENGTH 50
 

// 查找字符在串中第一次出现位置
 int strpos(const char *str, const char ch)
 {
  int i;
 
 for(i = 0; i < strlen(str); i++)
  {
   if(str[i] == ch)
    break;
  }
  return i;
 }
 
// 判断运算符优先级
 int operPrior(const char oper)
 {
  char operList[] = {'-', '+', '*', '/', '(', ')', ''}; // 6种运算符
 
 return strpos(operList, oper) / 2;
 }
 
// 计算求值
 bool calc(float a, float b, char oper, float *result)
 {
  switch(oper)
  {
  case '+':
   *result = a + b;
   break;
  case '-':
   *result = a - b;
   break;
  case '*':
   *result = a * b;
   break;
  case '/':
   if(b != 0)
    *result = a / b;
   else
    return false;
   break;
  default:
   *result = 0;
   return false;
  }
  return true;
 }
 
// 表达式求值计算处理函数
 bool calcExpression(const char *exp, float *result)
 {
  SqStack ope; // 运算符栈
  SqStack num; // 操作数栈
  ET buf;   // 暂存入栈、出栈元素
  unsigned short pos = 0;     // 表达式下标
  char operand[MAX_OPERAND_LENGTH] = {0}; // 操作数
  char operList[] = {'-', '+', '*', '/', '(', ')', ''}; // 6种运算符
  // 初始化栈
  InitStack(&ope);
  InitStack(&num);
 
 buf.cElem = '#';
  if(false == Push(&ope, buf))
   return false;
 
 // 字符串处理，入栈，计算求值
  while(strlen(exp) > pos)
  {
   // ASCII 48~57 为数字  .(小数点) 为 46
   if(exp[pos] >= 48 && exp[pos] <= 57 || exp[pos] == 46)  //若扫描的字符为数字0~9或者小数点'.'
   {
    // 下标从pos开始，长度为len的字符串为操作数
    int len = 1;
    // 求数字字符长度len
    while(exp[pos + len] >= 48 && exp[pos + len] <= 57 || exp[pos + len] == 46)
    {
     len++;
    }
    
    strncpy(operand, (exp + pos), len);
    operand[len] = '';
    // 将字符串操作数转化为浮点数
    buf.fElem = atof(operand);
    // 入栈
    if(false == Push(&num, buf))
     return false;
    // 修改pos指示位置
    pos += len;
   }
   else if(strchr(operList, exp[pos]) != NULL) // 为运算符
   {
 
   GetTop(ope, &buf);
    if('#' == buf.cElem || ( '(' == buf.cElem && exp[pos] != ')' ))
    {
     buf.cElem = exp[pos];
     if(false == Push(&ope, buf))
      return false;
    }
    else
    {
     // 比较运算符的优先级
     if(operPrior(buf.cElem) < operPrior(exp[pos]) && exp[pos] != ')')
     {
      // 运算符入栈
      buf.cElem = exp[pos];
      if(false == Push(&ope, buf))
       return false;
      
     }
     else 
     {
      GetTop(ope, &buf);
      if(buf.cElem == '(' && exp[pos] == ')')
      {
       if(false == Pop(&ope, &buf))
        return false;
      }
      else
      {
       float num1, num2, res;
       char op;
       // 取运算符
       if(false == Pop(&ope, &buf))
        return false;
       op = buf.cElem;
       // 取第一个操作数
       if(false == Pop(&num, &buf))
        return false;
       num1 = buf.fElem;
       // 取第二个操作数
       if(false == Pop(&num, &buf))
        return false;
       num2 = buf.fElem;
 
      // 调用计算函数
       if(false == calc(num2, num1, op, &res))
        return false;
       // 结果入栈
       buf.fElem = res;
       if(false == Push(&num, buf))
        return false;
 
      // pos回溯，下一轮再次处理此运算符，因为此次未处理(只运算符出栈，计算)
       pos--;
      }
     }
    }// else
 
   // 处理完运算符，指示器加1
    pos++;
   }
   else // 为非法字符
   {
    return false;
   }
  }// while
 
 // 表达式遍历完一遍后, 运算符出栈，依次计算即可
  while(true)
  {
   GetTop(ope, &buf);
   if(buf.cElem == '#')
    break;
   float num1, num2, res;
   char op;
   // 取运算符
   if(false == Pop(&ope, &buf))
    return false;
   op = buf.cElem;
   // 取第一个操作数
   if(false == Pop(&num, &buf))
    return false;
   num1 = buf.fElem;
   // 取第二个操作数
   if(false == Pop(&num, &buf))
    return false;
   num2 = buf.fElem;
 
  // 调用计算函数
   if(false == calc(num2, num1, op, &res))
    return false;
   // 结果入栈
   buf.fElem = res;
   if(false == Push(&num, buf))
    return false;
  }
 

 if(1 == StackLength(num))
  {
   if(false == Pop(&num, &buf))
    return false;
   *result = buf.fElem;
  }
  else
  {
   return false;
  }
 
 // 销毁栈
  DestroyStack(&ope);
  DestroyStack(&num);
 
 return true;
 }// calcExpression
 
// 初始化程序的界面提示信息
 void initTip(void)
 {
  printf("表达式求值模拟程序n");
  printf("n功能菜单：n");
  printf("=====================n");
  printf("[1]输入表达式求值n[0]退出n");
  printf("=====================n");
 }// initTip
 

int main(void)
 {
  int selectNum = 0;     // 记录选择的命令
  char exp[MAX_EXPRESSION_LENGTH] = {0}; // 表达式
  float result; // 存储结果
  // 初始化提示信息
  initTip(); 
  
  do{
   printf("请输入你的选择 (0～1)：");
   scanf("%d", &selectNum);
   
   switch(selectNum)
   {
   case 0:
    break;
 
  case 1:
    // input expression
    printf("请输入表达式：");
    scanf("%s", exp);
    fflush(stdin);
    // 调用表达式求值函数
    if(false == calcExpression(exp, &result))
    { 
     printf("表达式错误！nn");
     continue;
    }
    else
    {
     // 输出运算结果
     printf("计算结果如下：n%s = %.3fnn", exp, result);
    }
    break;
 
  default:
    printf("选择非法！ 请重新选择。nn");
    fflush(stdin);
    continue;
   }// switch
 
 }while(selectNum != 0);
 
 return 0;
 }
 
 
 
 
 
 
 
//DynaSeqStack.h
 
/***
 *DynaSeqStack.h - 动态顺序栈的定义
 * 
 ****/
 
#if !defined(DYNASEQSTACK_H)
 #define DYNASEQSTACK_H
 
#include "ElemType.h"
 
/*------------------------------------------------------------
 // 栈结构的定义
 ------------------------------------------------------------*/
 typedef struct Stack
 {
  ElemType *base;    // 栈基址
  ElemType *top;    // 栈顶
  int stacksize;    // 栈存储空间的尺寸
 } SqStack;
 
/*------------------------------------------------------------
 // 栈的基本操作
 ------------------------------------------------------------*/
 
bool InitStack(SqStack *S);
 void DestroyStack(SqStack *S);
 bool StackEmpty(SqStack S);
 int  StackLength(SqStack S);
 bool GetTop(SqStack S, ElemType *e);
 void StackTraverse(SqStack S, void (*fp)(ElemType));
 bool Push(SqStack *S, ElemType e);
 bool Pop(SqStack *S, ElemType *e);
 
#endif /* DYNASEQSTACK_H */
 

//DynaSeqStack.cpp
 
/***
 *DynaSeqStack.cpp - 动态顺序栈，即栈的动态顺序存储实现
 *
 *
 *说明：栈的动态顺序存储实现
 *
 * 
 ****/
 
#include <stdlib.h>
 #include <malloc.h>
 #include <memory.h>
 #include <assert.h>
 #include "DynaSeqStack.h"
 
const int STACK_INIT_SIZE = 100; // 初始分配的长度
 const int STACKINCREMENT  = 10;  // 分配内存的增量
 
/*------------------------------------------------------------
 操作目的： 初始化栈
 初始条件： 无
 操作结果： 构造一个空的栈
 函数参数：
   SqStack *S 待初始化的栈
 返回值：
   bool  操作是否成功
 ------------------------------------------------------------*/
 bool InitStack(SqStack *S)
 {
  S->base = (ElemType *)malloc(sizeof(ElemType) * STACK_INIT_SIZE);
  if(NULL == S->base)
   return false;
  S->top = S->base;
  S->stacksize = STACK_INIT_SIZE;
 
 return true;
 }
 
/*------------------------------------------------------------
 操作目的： 销毁栈
 初始条件： 栈S已存在
 操作结果： 销毁栈S
 函数参数：
   SqStack *S 待销毁的栈
 返回值：
   无
 ------------------------------------------------------------*/
 void DestroyStack(SqStack *S)
 {
  if(S != NULL)
  {
   free(S->base);
   S = NULL; // 防止野指针
  }
 }
 
/*------------------------------------------------------------
 操作目的： 判断栈是否为空
 初始条件： 栈S已存在
 操作结果： 若S为空栈，则返回true，否则返回false
 函数参数：
   SqStack S 待判断的栈
 返回值：
   bool  是否为空
 ------------------------------------------------------------*/
 bool StackEmpty(SqStack S)
 {
  return (S.base == S.top);
 }
 
/*------------------------------------------------------------
 操作目的： 得到栈的长度
 初始条件： 栈S已存在
 操作结果： 返回S中数据元素的个数
 函数参数：
   SqStack S 栈S
 返回值：
   int   数据元素的个数
 ------------------------------------------------------------*/
 int StackLength(SqStack S)
 {
  return (S.top - S.base);
 }
 
/*------------------------------------------------------------
 操作目的： 得到栈顶元素
 初始条件： 栈S已存在
 操作结果： 用e返回栈顶元素
 函数参数：
   SqStack S 栈S
   ElemType *e 栈顶元素的值
 返回值：
   bool  操作是否成功
 ------------------------------------------------------------*/
 bool GetTop(SqStack S, ElemType *e)
 {
  if(NULL == e)
   return false;
  *e = *(S.top - 1);
  return true;
 }
 
/*------------------------------------------------------------
 操作目的： 遍历栈
 初始条件： 栈S已存在
 操作结果： 依次对S的每个元素调用函数fp
 函数参数：
   SqStack S  栈S
   void (*fp)() 访问每个数据元素的函数指针
 返回值：
   无
 ------------------------------------------------------------*/
 void StackTraverse(SqStack S, void (*fp)(ElemType))
 {
  if(NULL == fp)
   return;
  for(int i = 0; i < (S.top - S.base); i++)
  {
   fp( *(S.base + i) );
  }
 }
 
/*------------------------------------------------------------
 操作目的： 压栈——插入元素e为新的栈顶元素
 初始条件： 栈S已存在
 操作结果： 插入数据元素e作为新的栈顶
 函数参数：
   SqStack *S 栈S
   ElemType e 待插入的数据元素
 返回值：
   bool  操作是否成功
 ------------------------------------------------------------*/
 bool Push(SqStack *S, ElemType e)
 {
  if( NULL == S ) // S为空
   return false;
  if((S->top - S->base) == S->stacksize) // 栈满
  {
   // 重新分配内存
   S->base = (ElemType *)realloc(S->base, sizeof(ElemType) * (S->stacksize + STACKINCREMENT));
   //修改top
   S->top = S->base + S->stacksize;
   //修改size
   S->stacksize += STACKINCREMENT;
  }
 
 *(S->top) = e;
  S->top++;
 
 return true;
 }
 
/*------------------------------------------------------------
 操作目的： 弹栈——删除栈顶元素
 初始条件： 栈S已存在且非空
 操作结果： 删除S的栈顶元素，并用e返回其值
 函数参数：
   SqStack *S 栈S
   ElemType *e 被删除的数据元素值
 返回值：
   bool  操作是否成功
 ------------------------------------------------------------*/
 bool Pop(SqStack *S, ElemType *e)
 {
  if(NULL == S || NULL == e || S->top == S->base) // S为空 或 e为空 或 栈空
   return false;
 
 S->top--;
  *e = *(S->top);
  return true;
 }

 

作者使用C语言中的共用体解决了栈的复用，有点类似于C++里面的模版类，这钟做法避免了因为不同的元素类型重复建立栈的数据结构，因为运算数栈和运算符栈的元素类型是不同的，一个为int、float、double类型，另一个为char型，当然如果使用C++写一个栈的类模版或者直接使用STL的stack就没这么麻烦了。

雪域迷影
关注
专栏目录
浅谈表达式求值问题
XiaoK's Blog
07-24 1106
1. 前言 经常会遇到这样一种类型的编程题目，给定一个合法算术运算式字符串（本文不考虑非法情况的判断和处理），求出它的计算结果，通常字符串中包含了 +-×/ 四则运算、改变运算优先级的括号 () 以及整数数字. 例如，要求程序输入 2×5+6×(3+2)2×5+6×(3+2)2×5+6×(3+2) 这样一个字符串，输出其正确的计算结果也就是 404040 . 2. 表达式表示法 表示方法有 3 种，分别是前缀表达式（波兰表达式）、中缀表达式、后缀表达式（逆波兰表达式），以之前的例子 2×5+6×(3+2)
表达式求值问题包括“+　-　×　／　（　）＂－－＞链表法
weixin_33781606的博客
01-07 389
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;string.h&gt;#define  error 0#define  ok   1#define  overflow  -1#define STACK_INIT_SIZE  100#define STACKINCREMENT 10#define OPSETSIZE  7c...
2-表达式求值
最新发布
weixin_68261440的博客
10-08 501
printf("请输入一个由+ - * / 数字 括号构成的表达式:\n");printf("请输入一个由+ - * / 数字 括号构成的表达式:\n");
详解表达式求值问题
暴力扬
03-28 785
详解比较熟悉的算术表达式，波兰数学家的灵感，中缀、后缀、前缀表达式，中缀表达式转后缀表达式的手算方法，后缀表达式的计算(手算)
含变量的表达式求值问题.rar
04-02
本项目围绕“含变量的表达式求值问题”展开，旨在通过改良和优化课本上的算法，解决如何高效准确地计算包含变量的数学表达式。下面将详细阐述相关知识点。 1. **表达式求值**：表达式求值是指根据一定的运算规则，...
JavaScript数据结构中栈的应用之表达式求值问题详解
10-20
在解决表达式求值问题时，栈的应用尤为关键。本篇将深入探讨如何利用栈解决表达式求值，特别是中缀表达式与后缀表达式之间的转换和求值。 首先，我们需要了解中缀表达式和后缀表达式的概念。中缀表达式是我们日常...
用栈解决表达式求值问题（数据结构）
10-28
### 用栈解决表达式求值问题（数据结构） #### 表达式求值与栈的应用 在计算机科学中，表达式的求值是一项常见的任务，尤其是在解析数学公式、执行编程语言中的运算等方面。通常，这类任务涉及到将一个复杂的数学...
表达式求值（c语言编写）
06-27
利用栈进行表达式求值，输入表达式，转化为后缀式再进行求值运算
基于栈实现表达式求值问题（C++）
weixin_44814196的博客
04-09 2623
目录一、问题描述二、实现思路三、解题代码四、运行结果 一、问题描述 基于栈实现表达式求值问题，输入一个简单表达式，输出表达式的结果 二、实现思路 在基于顺序栈实现表达式求值中，该算法主要分为将算术表达式转换成后缀表达式和后缀表达式求值两个步骤。 将算术表达式转换为后缀表达式的主要思路为：在从左到右扫描算术表达式exp的一个运算符op时，如果栈为空或者栈顶为’(‘，直接将其进栈；如果栈不空，只有当op的优先级高于栈顶运算符的优先级时才直接将op进栈;否则依次出栈运算符并存人后缀表达式postexp。直
表达式求值的问题
lance家园
10-20 1753
#include#include#include#define FALSE 0#define TRUE 1#define ERROR 0#define OK 1#define OVERFLOW -1typedef int Status;//stacktypedef char SElemType;#define STACK_INIT_SIZE 100//存储空间初始量#define STACK_IN
表达式求值问题二叉树
03-28
表达式求值问题可以通过构建二叉树来解决。在二叉树中，每个节点都表示一个操作符或者操作数。通过遍历二叉树，可以按照特定的规则计算出表达式的值。 具体的构建过程如下： 1. 将表达式转换为后缀表达式（逆波兰表达式）。 2. 从左到右扫描后缀表达式，遇到操作数则将其入栈，遇到操作符则从栈中弹出相应数量的操作数进行计算，并将计算结果入栈。 3. 最终栈中剩下的元素即为表达式的计算结果。 举个例子来说明： 假设有一个中缀表达式：3 + 4 * 2 - 5 将其转换为后缀表达式：3 4 2 * + 5 - 构建对应的二叉树如下： - / \ + 5 / \ 3 * / \ 4 2 按照后缀表达式的顺序遍历二叉树，得到计算结果为：6
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值