栈：中缀表达式转后缀表达式(逆波兰式)求值（支持多位数）【C语言，数据结构】（内含源代码）

已于 2022-11-20 16:22:16 修改
阅读量1.3k 收藏 15
点赞数 3
分类专栏： 数据结构 C语言 文章标签： 数据结构 c语言 算法
于 2022-10-30 11:32:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62792553/article/details/127595117
版权

目录

题目：

需求分析：

概要设计：

详细设计：

3.转逆波兰表达式 

4.逆波兰表达式求值

总结：

 用户手册：

测试结果：

 源代码：

题目：

设计并验证以下算法： 首先将一个中缀表达式转换成逆波兰式（后缀表达式），然后对此逆波兰表达式求值。

需求分析：

1.输入分析：可能输入正确的和错误的表达式，可能输入超过一位的数字，输入的表达式可能产生浮点类型的结果，输入中空格可能出现在任何地方，输入由‘#’结尾。（现只输入整数）

2.演示程序在用户输入完整表达式后，若表达式不合法则输出相应提示，先输出用户表达式，再输出逆波兰表达式，最后输出其结果。

3.程序执行命令包括：(1)接受输入 (2)判断输入 (3)求逆波兰式 (4)根据逆波兰式求值 

4.测试数据：

1+1#

1+2*3-4/5#

(4+2)*3-3/2#

(4+2)*(8-2)/2#

概要设计：

1.输入数据可以用数组存储，或者用顺序表存储，在本次实验用数组存储。

2.判断与转换同时进行。数据处理部分，为了使程序更快，只用遍历一次原输入，所以在这里让判断正误与转逆波兰表达式同时进行。

3.使用两种栈。在表达式转逆波兰表达式的时候需要用到栈来存储操作符，并且在使用逆波兰式表达式求值的时候也要用到栈来存储数，所以用要用两种栈来存储不同的数据类型。

4.程序模块：

（1）主程序模块：

void main(){
    初始化
    接受输入
    判断与转换
    求值
    输出
    结束
}

详细设计：

1.跳过空格。输入的数据和符号在用户看来，为了美观可能会添加空格，所以在我们转逆波兰表达式的时候要跳过空格来处理字符。

2.空格隔开数。因为输入可能是多位数，在后缀表达式里，我们怎么区分一个数是否为多位数呢？我想到的方法是用空格来个开各个数，这样就能区分了。详细操作是，每当遇到操作符，代表上一个数已经遍历完毕，在表达式数组中存入空格，来分开数据。

e9d0087bddec4baeb20fe03e20ef044f.gif

3.转逆波兰表达式 

算法是这样的，从头开始遍历输入，当遇到数，就直接存入顺序表中。遇到符号时，就进行特殊处理：

当栈内元素为空的时候，直接存入：

61934a87c1a046e08786a49120b7ca15.gif

 当栈内有元素的时候，特殊处理。具体为，栈内优先级低于该符号则存入栈内，栈内优先级高于该符号，则把栈内符号输出，继续比较栈内符号。（操作会直到栈内符号优先级高于它，或栈内为空的时候）：

845929017a83406188b969e12ad07192.gif

 f18216f3bb8e4f0a953327ede745d9c7.gif

括号特殊处理。可以看做'('的优先级高于一切， ')'时，输出栈内元素，直到栈内上一个'('。

遍历完所有后，清空栈内元素，当遍历完所有元素后，把栈内剩余的操作符全部出栈。

对，就是这么简单。

void GetPE(SqList L, SqList *PE) {
	//根据输入求后缀表达式，若输入错误则报错
	int f = 1;			//判断输入工具
	int l = L.length;
	SqStack OP;			//操作符栈
	char c;
	int s = 0;
	InitStack(&OP);
	if(L.elem[0] <= '9' && L.elem[0] >= '0') {
		f = 0;
	}
	for(int i = 0; i < l; i++) {
		if(L.elem[i] <= '9' && L.elem[i] >= '0') {
			f = 0;
			ListInsert_SqList(PE, -1, L.elem[i]);
		} else {
			if(L.elem[i] != '(' && L.elem[i] != ')') {

				if(i != 0 && f == 1) {
					printf("ERROR!");
					exit(ERROR);
				}
				f = 1;
			}
			if(L.elem[i] == '(') {
				Push(&OP, L.elem[i]);
			} else if(L.elem[i] == ')') {
				Pop(&OP, &c);
				while(c != '(') {
					ListInsert_SqList(PE, -1, c);
					Pop(&OP, &c);
				}
			} else if(L.elem[i] == '+' || L.elem[i] == '-') {
				s = GetTop(OP, &c);
				while(s != 0 && c != '(') {
					Pop(&OP, &c);
					ListInsert_SqList(PE, -1, c);
					s = GetTop(OP, &c);
				}
				Push(&OP, L.elem[i]);
			} else if(L.elem[i] == '/' || L.elem[i] == '*') {
				s = GetTop(OP, &c);
				while(s == 1 && (c == '*' || c == '/')) {
					Pop(&OP, &c);
					ListInsert_SqList(PE, -1, c);
					s = GetTop(OP, &c);
				}
				Push(&OP, L.elem[i]);
			}
			if(L.elem[i] != '(' && L.elem[i] != ')') {
				ListInsert_SqList(PE, -1, ' ');
			}
		}
	}
	s = GetTop(OP, &c);		//判断并输出栈中剩余符号
	while(s) {
		Pop(&OP, &c);
		ListInsert_SqList(PE, -1, c);
		s = GetTop(OP, &c);
	}
}

4.逆波兰表达式求值

逆波兰表达式的方法很简单，就是遇到符号就进行前两个数的计算，在入栈。

不会的推荐这一篇文章。

http://t.csdn.cn/yOqQN

float GetPEResult(SqList L) {
	//根据后缀表达式求结果
	float sum = 0, tool2;
	int tool, flag;
	int l = L.length;
	SqStack2 PR;			//数字栈
	InitStack2(&PR);
	for(int i = 0; i < l; i++) {
		tool = 0, flag = 0, tool2 = 0, sum = 0;
		while(L.elem[i] <= '9' && L.elem[i] >= '0') {
			tool = tool * 10;
			tool += L.elem[i] - '0';
			i++;
			flag = 1;
		}
		if(flag == 1) {
			Push2(&PR, (float)tool);
		}
		switch(L.elem[i]) {
		case '+':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, tool2 + sum);
			break;
		case '-':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, sum - tool2);
			break;
		case '*':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, tool2 * sum);
			break;
		case '/':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, sum / tool2);
			break;
		}
	}
	Pop2(&PR, &sum);
	return sum;
}

总结：

这个程序还可以简化，在转逆波兰的时候，用到了很多if语句，还可以把操作符的优先级做成一张表格，通过表格来进行判断。

e0bef80a575d41b38c3c6ebee504f817.png

 用户手册：

1.本程序运行环境为DOS。

2.输入表达式后#结束，回车

3.根据输入，程序输出逆波兰表达式与结果。

测试结果：

64d29dea75b7413e8a03b6b994e8c557.png

 d3fef885f9e24e43b4b4295ab2049b25.png

 db4bb8be28984d6ab8204562214f1d07.png

 91318d614d51471fa8f216327da54027.png

 f6184bbf72f145468d511f40aaa5d10b.png

 源代码：

主程序：

#include "head.h"

void Input(SqList * );	//把输入进行特殊处理后存入，#结束
void GetPE(SqList, SqList *);	//根据输入求后缀表达式，若输入错误则报错
float GetPEResult(SqList);	//根据后缀表达式求结果

int main() {
	float answer;
	SqList input, PE;		//初始化
	InitList_SqList(&input);
	InitList_SqList(&PE);

	printf("Please enter your expression and end with '#':\n");
	Input(&input);	//把输入存入input中

	printf("Your input is: ");	//输出原式
	printlist_SqList(input);

	GetPE(input, &PE);	//输出逆波兰式
	printf("To RPExpression is: ");
	printlist_SqList(PE);

	answer = GetPEResult(PE);
	printf("Answer is: %.2lf", answer);

	return 0;
}

void Input(SqList *input) {
	//把输入进行特殊处理后存入，#结束
	ElemType c;
	while(1) {
		scanf(" %c", &c);
		if(c == '#') {
			break;
		}
		ListInsert_SqList(input, -1, c);
	}
}

void GetPE(SqList L, SqList *PE) {
	//根据输入求后缀表达式，若输入错误则报错
	int f = 1;			//判断输入工具
	int l = L.length;
	SqStack OP;			//操作符栈
	char c;
	int s = 0;
	InitStack(&OP);
	if(L.elem[0] <= '9' && L.elem[0] >= '0') {
		f = 0;
	}
	for(int i = 0; i < l; i++) {
		if(L.elem[i] <= '9' && L.elem[i] >= '0') {
			f = 0;
			ListInsert_SqList(PE, -1, L.elem[i]);
		} else {
			if(L.elem[i] != '(' && L.elem[i] != ')') {

				if(i != 0 && f == 1) {
					printf("ERROR!");
					exit(ERROR);
				}
				f = 1;
			}
			if(L.elem[i] == '(') {
				Push(&OP, L.elem[i]);
			} else if(L.elem[i] == ')') {
				Pop(&OP, &c);
				while(c != '(') {
					ListInsert_SqList(PE, -1, c);
					Pop(&OP, &c);
				}
			} else if(L.elem[i] == '+' || L.elem[i] == '-') {
				s = GetTop(OP, &c);
				while(s != 0 && c != '(') {
					Pop(&OP, &c);
					ListInsert_SqList(PE, -1, c);
					s = GetTop(OP, &c);
				}
				Push(&OP, L.elem[i]);
			} else if(L.elem[i] == '/' || L.elem[i] == '*') {
				s = GetTop(OP, &c);
				while(s == 1 && (c == '*' || c == '/')) {
					Pop(&OP, &c);
					ListInsert_SqList(PE, -1, c);
					s = GetTop(OP, &c);
				}
				Push(&OP, L.elem[i]);
			}
			if(L.elem[i] != '(' && L.elem[i] != ')') {
				ListInsert_SqList(PE, -1, ' ');
			}
		}
	}
	s = GetTop(OP, &c);		//判断并输出栈中剩余符号
	while(s) {
		Pop(&OP, &c);
		ListInsert_SqList(PE, -1, c);
		s = GetTop(OP, &c);
	}
}
float GetPEResult(SqList L) {
	//根据后缀表达式求结果
	float sum = 0, tool2;
	int tool, flag;
	int l = L.length;
	SqStack2 PR;			//数字栈
	InitStack2(&PR);
	for(int i = 0; i < l; i++) {
		tool = 0, flag = 0, tool2 = 0, sum = 0;
		while(L.elem[i] <= '9' && L.elem[i] >= '0') {
			tool = tool * 10;
			tool += L.elem[i] - '0';
			i++;
			flag = 1;
		}
		if(flag == 1) {
			Push2(&PR, (float)tool);
		}
		switch(L.elem[i]) {
		case '+':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, tool2 + sum);
			break;
		case '-':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, sum - tool2);
			break;
		case '*':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, tool2 * sum);
			break;
		case '/':
			Pop2(&PR, &tool2);
			Pop2(&PR, &sum);
			Push2(&PR, sum / tool2);
			break;
		}
	}
	Pop2(&PR, &sum);
	return sum;
}

头文件：

#include <stdio.h> 			//头文件
#include <stdlib.h>
#include <malloc.h>
#include <conio.h>
#include <string.h>

#define TRUE 1	//函数结果状态码
#define FALSE 0
#define ERROR 0
#define OK 1
#define EQUAL 1
#define OVERFLOW -1
#define INFEASIBLE -2
#define STACK_INIT_SIZE 100	//存储空间初始分配量
#define STACKINCREMENT 10	//存储空间分配增量
#define LIST_INIT_SIZE 100	//顺序表存储空间的初始分配量
#define LISTINCREMENT 10	//顺序表存储空间的分配增量

typedef int Status;	//Status 为函数返回值类型，其值为函数结果状态代码

typedef char SElemType;	//栈中数据元素类型为char型
typedef float SElemType2;	//栈中数据元素类型为float型

typedef struct {	//栈的顺序存储表示
	SElemType* base;	//栈构造之前和销毁之后，其值为NULL
	SElemType* top;	//栈顶指针
	int stacksize;	//当前已分配的存储空间
} SqStack;

typedef struct {	//栈的顺序存储表示
	SElemType2* base;	//栈构造之前和销毁之后，其值为NULL
	SElemType2* top;	//栈顶指针
	int stacksize;	//当前已分配的存储空间
} SqStack2;

typedef char ElemType;//顺序表中数据元素类型

struct LIST {
	ElemType* elem;			//顺序表的存储空间基址
	int length;				//当前长度
	int listsize;			//当前分配的存储容量
};
typedef struct LIST SqList;	//线性表的顺序存储结构定义

Status InitStack(SqStack*);			//栈初始化
Status DestroyStack(SqStack*);		//销毁栈
Status StackEmpty(SqStack);			//栈判空
Status GetTop(SqStack, SElemType*);	//取栈顶元素
Status Push(SqStack*, SElemType);	//入栈
Status Pop(SqStack*, SElemType*);	//出栈
Status StackTraverse(SqStack);		//遍历栈，输出每个数据元素
Status InitList_SqList(SqList*);	//构造一张新的顺序表L
Status ListInsert_SqList(SqList*, int, ElemType );	//在顺序表L的第i个元素前插入新元素e
int ListLength_SqList(SqList);		//求顺序表L的长度
Status Destroy_SqList(SqList*);		//销毁一张顺序表
void printlist_SqList(SqList);		//输出顺序表
Status InitStack2(SqStack2*);			//栈初始化
Status DestroyStack2(SqStack2*);		//销毁栈
Status StackEmpty2(SqStack2);			//栈判空
Status GetTop2(SqStack2, SElemType2*);	//取栈顶元素
Status Push2(SqStack2*, SElemType2);	//入栈
Status Pop2(SqStack2*, SElemType2*);	//出栈
Status StackTraverse2(SqStack2);		//遍历栈，输出每个数据元素

Status InitStack(SqStack* S) {
	//构造一个空栈Ss
	S->base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if(!S->base) {
		//存储分配失败
		exit(OVERFLOW);
	}
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}//InitStack

Status GetTop(SqStack S, SElemType* e) {
	//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top == S.base) {
		return ERROR;
	}
	*e = *(S.top - 1);
	return OK;
}//GetTop

Status Push(SqStack* S, SElemType e) {
	//插入元素e为新的栈顶元素
	if(S->top - S->base >= S->stacksize) {
		//栈满，追加存储空间
		S->base = (SElemType*)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(SElemType));
		if(!S->base) {
			//存储分配失败
			exit(OVERFLOW);
		}
		S->top = S->base + S->stacksize;
		S->stacksize += STACKINCREMENT;
	}
	*S->top++ = e;
	return OK;
}//Push

Status Pop(SqStack* S, SElemType* e) {
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROE
	if(S->top == S->base) {
		return ERROR;
	}
	*e = *(--S->top);
	return OK;
}//Pop

Status DestoryStack(SqStack* S) {
	//销毁栈S
	if(S->base) {
		free(S->base);
	}
	S->top = S->base = NULL;
	return OK;
}//DestroyStack

Status StackTraverse(SqStack S) {
	//遍历栈，输出每一个数据元素
	SElemType* p = S.base;
	int i = 0;
	if(S.base == S.top) {
		printf("Stack is Empty.\n");
		return OK;
	}
	while(p < S.top) {
		printf("[%d:%c]", ++i, *p++);
	}
	printf("\n");
	return OK;
}//StackTraverse

Status InitStack2(SqStack2* S) {
	//构造一个空栈Ss
	S->base = (SElemType2*)malloc(STACK_INIT_SIZE * sizeof(SElemType2));
	if(!S->base) {
		//存储分配失败
		exit(OVERFLOW);
	}
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
	return OK;
}//InitStack

Status GetTop2(SqStack2 S, SElemType2* e) {
	//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top == S.base) {
		return ERROR;
	}
	*e = *(S.top - 1);
	return OK;
}//GetTop

Status Push2(SqStack2* S, SElemType2 e) {
	//插入元素e为新的栈顶元素
	if(S->top - S->base >= S->stacksize) {
		//栈满，追加存储空间
		S->base = (SElemType2*)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(SElemType2));
		if(!S->base) {
			//存储分配失败
			exit(OVERFLOW);
		}
		S->top = S->base + S->stacksize;
		S->stacksize += STACKINCREMENT;
	}
	*S->top++ = e;
	return OK;
}//Push

Status Pop2(SqStack2* S, SElemType2* e) {
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROE
	if(S->top == S->base) {
		return ERROR;
	}
	*e = *(--S->top);
	return OK;
}//Pop

Status DestoryStack2(SqStack2* S) {
	//销毁栈S
	if(S->base) {
		free(S->base);
	}
	S->top = S->base = NULL;
	return OK;
}//DestroyStack

Status StackTraverse2(SqStack2 S) {
	//遍历栈，输出每一个数据元素
	SElemType2* p = S.base;
	int i = 0;
	if(S.base == S.top) {
		printf("Stack is Empty.\n");
		return OK;
	}
	while(p < S.top) {
		printf("[%d:%.2lf]", ++i, *p++);
	}
	printf("\n");
	return OK;
}//StackTraverse

Status InitList_SqList(SqList* L) {	//构造一个空顺序表L
	L->elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType)); //分配内存
	if(!L->elem)
		exit(OVERFLOW);
	L->length = 0;
	L->listsize = LIST_INIT_SIZE;
	return OK;
}	//InitList_SqList

Status ListInsert_SqList(SqList* L, int i, ElemType e) {	//在顺序表L的第i个元素前插入新元素e
	ElemType* newbase, *p, *q;
	if(i == -1) {
		i = L->length + 1;
	}
	if(i < 1 || i > L->length + 1)
		return ERROR;				//插入位置不合法
	if(L->length >= L->listsize) {	//当前存储空间已满，增加分配
		newbase = (ElemType*)realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof(ElemType));
		if(!newbase)
			return ERROR;			//存储分配失败
		L->elem = newbase;			//新基址
		L->listsize += LISTINCREMENT;	//增加存储容量
	}
	q = &(L->elem[i - 1]);			//q指向插入位置
	for(p = &L->elem[L->length - 1]; p >= q; --p)
		*(p + 1) = *p;				//插入位置之后的数据元素右移
	*q = e;							//插入e
	L->length++;
	return OK;
}	//ListInsert_SqList

int ListLength_SqList(SqList L) {	//求顺序表L的长度
	return L.length;
}	//ListLength_SqList;

Status Destroy_SqList(SqList* L) {	//销毁一张顺序表
	free(L);
	return OK;
}	//Destroy_SqList

void printlist_SqList(SqList L) {	//输出顺序表
	int i;
	for(i = 0; i < L.length; i++)
		printf("%c", L.elem[i]);
	printf("\n");
}	//printlist_SqList;

哦豁果奶
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中缀表达式转换为后缀表达式及逆波兰式求值
01-10
后缀表达式在计算和解析上更为高效，尤其是通过栈数据结构进行求值。 **中缀表达式转后缀表达式**： 这个过程通常涉及到一个称为“操作符栈”的数据结构。遍历中缀表达式的每个字符，如果遇到操作数，则直接输出；...
C语言：中缀算术表达式求值（栈 附答案）.docx
10-26
在C语言中，中缀表达式求值是一个常见的编程问题，它涉及到数据结构中的栈这一概念。本题目的目标是设计一个程序，能够接收一个中缀表达式（包含加、减、乘、除和括号），然后计算其结果。为了实现这个功能，我们...
数据结构——c语言 中缀多项式转换后缀并求值
起当风萧的博客
04-11 1028
设计并验证以下算法:首先将一个中缀表达式转换成逆波兰式，然后对此逆波兰表达式求值。 (1)表达式求值是程序设计语言编译中的一个最基本的问题。通常，表达式由运算符、操作数、界限符组成，算术表达式中最常见的表示法形式有中缀、前缀和后缀表示法。中缀表示法是书写表达式的常见方式，前缀和后缀表示法主要用于计算机科学领域。 ①中缀表达式:运算符在两操作数的中间。在运算中存在运算符的优先权与结合性的问题。例如运算a/b-(c+d)*f时，编译器即自左向右逐一检查，当检查到第一个运算符“/”时还无法知道是否执行；待检查到.
【每天一道算法题】栈的应用：将中缀表达式转为后缀表达式以及后缀表达式求值(附动图，源码，讲解最详细，没有之一)
Learning_xzj的博客
05-06 2815
🌱本专栏将会从基础开始，循序渐进，每天刷一道算法题，也请大家多多支持。数据结构虽然难，但只要肯坚持，一定能学好，希望大家都能够从中获益。 📫专栏地址: 🍇每日一道算法题专栏 🍉数据结构专栏 📫本专栏的所有代码都将更新在Gitee上，项目地址：项目地址 📫相关数据结构演示软件:链接地址 📫数据结构在线演示地址：https://visualgo.net/zh https://algorithm-visualizer.org/ 准备好了吗 Let’s go! 1 栈在表达式.
中缀表达式转后缀表达式并求值
Gnomeshgh的博客
02-05 3553
想要自己手写一个计算器吗，快来看这篇博客吧，这篇博客会教你从0开始实现一个自己的简易计算器，当然了，你需要有一点点的计算机基础知识，比如对栈这个结构有一丝丝的印象。
中缀表达式转后缀表达式（逆波兰式）
qq_33300585的博客
09-07 1947
中缀表达式转后缀表达式（逆波兰式）
中缀表达式转后缀表达式
qq_49169308的博客
12-23 1万+
一、中缀表达式和后缀表达式的区别： 中缀表达式就是我们通常认知中的表达式，比如1+((2+3)*4)-5，这样的表达式虽然容易被人所理解，但是不容易被机器所识别，为此推出了后缀表达式。 后缀表达式又被叫做逆波兰表达式，逆波兰表达式不需要被括号所识别，且容易被机器识别。 二、中缀表达式转后缀表达式的过程： 我们随意的拟定一个中缀表达式，比如：1+5*(3+2)-4*5； 我们对中缀表达式进行一步一步转换，转换方式如下： 1、遇到操作数时直接加入集合 2、遇到操作符，与栈顶操作符比较优先级   2.1、如果
Java数据结构与算法-栈（逆波兰表达式）原理及代码实现
12-22
代码通常会定义一个栈类，如`Stack`，并实现中缀表达式转后缀表达式的功能。在给定的Java代码中，`Calculate`类提供了`zhongXU`方法将字符串转换为中缀表达式列表，`houXU`方法完成中缀转后缀，最后`cal`方法进行...
数据结构实验报告-栈与队列-中缀表达式转换为后缀式5分-实验内容及要求.docx
03-11
西南交通大学 报告仅供参考，请独立完成作业
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
最新发布
06-29
严蔚敏《数据结构》实验二：基于栈的中缀算数表达式求值
中缀表达式转换为后缀表达式，并计算
热爱编程的菜鸟
11-05 987
**中缀表达式：**中缀表达式是一个通用的算术或逻辑公式表示方法 **后缀表达式：**也叫逆波兰式 关系： 中缀表达式：a+b 后缀表达式：a b + 我们对中缀表达式比较熟悉，对后缀表达式感觉难懂，但对于计算机来说，则后缀表达式比较好理解。 首先我们先看看后缀表达式如何运算： 1.a b + 假设有一个栈中存放数值； 从左到右我们如果遇见的是数值，则直接压入栈中，则栈中有a b 两个数值，当遇到运算符就从栈中取出两个数进行运算，将计算结果重新压入栈中，最后栈中的结构就是a+b； 2.ab+c*ab+e/-
【数据结构】中缀表达式转后缀表达式求值
这里是Mae。
10-12 6076
后缀表达式求值 首先需要将输入的中缀表达式转换成后缀表达式。 后缀表达式中，操作符在后 例如：1+2*(5-3)+4 后缀表达式：1253-*+4+ 1、中缀表达式转换成后缀表达式方法： 首先，需要定义一个操作符栈并且知道各运算符优先级，然后从左往右一次扫描字符(字符前后加#号)，遇到数字直接输出，遇到操作符比较优先级。 栈顶优先级低，入栈； 栈顶优先级高，出栈并且输出； 优先级相等(即左右括号)，出栈(不输出)； 当扫描的字符为#并且栈顶字符为#时，此时输出的字符序列即为后缀表达式 2、后缀表达式求值过程
中缀表达式转后缀表达式(逆波兰式)并且计算结果
weixin_44520881的博客
09-06 808
原理省去，给出了思路和代码。 思路: (1)中缀表达式转后缀表达式 设一个运算符栈，用来临时存放操作符，一个队列，用来存放生成的后缀表达式。 从左向右扫描中缀表达式，如果遇到操作数num：直接添加num到后缀表达式队列中。 如果遇到的是运算符op1:如果该运算符op1比栈顶运算符优先级高，则把该操作符op1入栈。否则把栈顶的运算符弹出加入到后缀表达式队列中，直到当前栈顶的元素优先级小于op1......
中缀表达式转后缀表达式并求值（多位数）
m0_48508203的博客
04-10 2755
中缀表达式转后缀表达式并求值（多位数） 一、问题简述 中缀表达式：是一种通用的算术或逻辑公式表示方法，操作符处于操作数的中间。中缀表达式是人们常用的算术表示方法，如3+5*8。 后缀表达式（逆波兰表达式）：运算符位于两个相应操作数之后，更方便计算机的运算，如3 5 8 * +。 为了方便计算机的运算，我们需要把中缀表达式转成后缀表达式。（也可直接计算中缀表达式的值） 二、背景题目：中缀表达式的值（北大oj平台） 描述 人们熟悉的四则运算表达式称为中缀表达式，例如(23+34*45/(5+6+7))。
中缀表达式转后缀表达式(逆波兰式)
这个人很懒, 什么都没留下(这是我写的)
05-02 1172
什么是逆波兰表达? 逆波兰表达式用来干嘛? 用栈模拟实现逆波兰表达式
【数据结构与算法 7】中缀表达式转为后缀表达式，实现逆波兰计算器
学Java，找哪吒
05-19 3863
一、中缀表达式 中缀表达式是一个通用的算术或逻辑公式表示方法。我们小学学的加减乘除就是所谓的中缀表达式，便于人类计算的表达式。 例如：（3+4）* 5 - 6 二、前缀表达式和后缀表达式 （3+4）* 5 - 6的前缀表达式是- * + 3 4 5 6 （3+4）* 5 - 6的后缀表达式是 3 4 + 5 * 6 - 后缀表达式较为常用，计算机熟悉的表达式，真狗。 三、中缀表达式转后缀表达式 这个有一个固定的思路，就像降龙十八掌秘籍一样，照着练就行了，如果你非要自创黯然销魂掌，你得自.
中缀表达式转换为后缀表达式（逆波兰表达式）
qq_38122800的博客
02-04 244
小甲鱼《数据结构与算法》-栈和队列6 转化规则：从左到右遍历中缀表达式的每个数字和符号，若是数字则直接输出，若是符号，则判断其与栈顶符号的优先级，是右括号或者优先级低于栈顶符号，则栈顶元素依次出栈并输出，直到遇到左括号或栈空才将等待的那个符号入栈。 /*将整数的四则运算的中缀表达式转换为后缀表达式*/ #include <stdio.h> #include <stdlib.h&...
计算器算法（逆波兰表达式）将中缀表达式转换为后缀表达式
lin17540的博客
05-29 138
定义变量 数组S1和S2(char类型)S1为存放“运算符”的数组，S2为存放”运算数”的数组 变量s1和s2(int类型)s1为存放“运算符”数组的长度可以理解为（栈顶），s2为存放“运算数”数组的长度可以理解为（栈顶初始值为-1） （如果你熟练使用栈也可以用栈） 如公式为： Char gs[]={“y+n*r+(88-77)-1”}; 入栈(“运算符和运算数”入栈都是一样的) s2++; S2[s2]=数据； 出栈(“运算符和运算数”出栈都是一样的) S2[s2]=空； s2--..
《数据结构》：中缀表达式转后缀表达式 + 后缀表达式的计算
热门推荐
Amentos的博客
10-07 7万+
《数据结构》实验报告：中缀/后缀/前缀表达式基本概念 + 前缀转后缀 + 后缀表达式的计算 + 完整算法实现
数据结构C语言 两种实现表达式计算方式
03-28
本篇文章主要探讨了如何使用C语言实现两种不同的表达式计算方法，包括中缀表达式转后缀表达式求值以及直接对中缀表达式求值。设计思想围绕着高效处理算术运算，首先介绍的是中缀转后缀（也称为逆波兰表示法）的方式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值