利用栈实现逆波兰算法

1.逆波兰表达式?

在我们的普遍认知中,计算的优先级总是和()相关,形如(1+2)*(3+4)这样的式子,我们看起来十分的清晰明了,但对计算机来说,它会进行很多次的判断来确定一个运算的优先级。于是在很久很久之前就有一个人发现,如果我们将上述算式写成形如1 2 + 3 4 + *的形式,计算机判断起来会显得格外的快,效率也会更高,然而它的实现原理是什么样的呢。

2.算法分析

经过观察,我们发现该算式将参数放在前面,运算操作符放在两个要进行计算的参数之后,我们可以得出这样的思路:每次我们将拿到的数据压栈,当遇见运算符时,就弹出两个数据让他们进行相应的计算,这样,计算完成之后我们再将运算结果入栈,最后我们拿到最终结果!

程序实例:

#include<iostream>
using namespace std;
typedef char Element;
struct Node
{
	Element data;
	Node *next;
	Node(Element d) :data(d), next(NULL)
	{}
};
class  DStack
{
private:
	Node *top;
	int size;
public:
	DStack() : top(NULL)
	{
	}
	~DStack()
	{
		if (top != NULL)
		{
			Node *del = top;
			top = top->next;
			delete del;
			del = NULL;
		}
	}
public:
	void Push(Element d)
	{
		Node *newNode = new Node(d);
		newNode->next = top;
		top = newNode;
		size++;
	}
	Element Pop()
	{
		Element re = top->data;
		top = top->next;
		size--;
		return re;
	}
};

int RPN()
{
	DStack s1;
	char tmp = 0;
	int a = 0, b = 0, c = 0;
	cout << "please enter a RPN :" << endl;
	while (1)
	{
		cin >> tmp;
		if (tmp == ‘#‘)
			break;
		switch (tmp)
		{
		case‘0‘:
		case‘1‘:
		case‘2‘:
		case‘3‘:
		case‘4‘:
		case‘5‘:
		case‘6‘:
		case‘7‘:
		case‘8‘:
		case‘9‘:
			s1.Push(tmp);
			break;
		case‘+‘:
			 a = s1.Pop()-‘0‘;
			 b = s1.Pop() - ‘0‘;
			 c = a + b;
			s1.Push(c + ‘0‘);
			break;
		case‘-‘:
			 a = s1.Pop() - ‘0‘;
			 b = s1.Pop() - ‘0‘;
			 c = a - b;
			s1.Push(c + ‘0‘);
			break;
		case‘*‘:
			 a = s1.Pop() - ‘0‘;
			 b = s1.Pop() - ‘0‘;
			 c = a * b;
			s1.Push(c + ‘0‘);
			break;
		case‘/‘:
			 a = s1.Pop() - ‘0‘;
			 b = s1.Pop() - ‘0‘;
			 c = a / b;
			s1.Push(c + ‘0‘);
			break;
		default:
			exit(0);
			break;
		}
	}
	int re = s1.Pop() - ‘0‘;
	return re;
}
int main()
{
	int a = RPN();
	cout << "计算结果是:" << a << endl;
	getchar();
	getchar();
	return 0;
}

综上,我们选择使用switch case控制流机制来实现我们的数据判断使程序显得简洁明了。

时间: 2024-10-13 14:38:09

利用栈实现逆波兰算法的相关文章

栈,逆波兰表达式???

这两天一直在想老师提出的要求:四个数的运算,让一个函数去实现,一次性的把四个数字以及三个运算符传递过去(数是随机产生的,运算符是随机产生的),说到随机产生运算符下面是我写的随机产生运算符的例子,但是还是没有达到自己想要的要求,自己也上网查了一些资料,但是介绍的都不是很详细,看不太懂,而且大部分都是些怎么不让其产生重复的元素. 这样写的结果是有些情况永远也出不来而且这样写的结果就好像是每一个数组里面的元素就好像是商量好了一样,说第几个元素出来就第几个元素出来,请求老师指导一下. 还说四个数的运算吧

【算法】表达式求值--逆波兰算法介绍

逆波兰算法介绍 假定给定一个只 包含 加.减.乘.除,和括号的算术表达式,你怎么编写程序计算出其结果. 问题是:在表达式中,括号,以及括号的多层嵌套 的使用,运算符的优先级不同等因素,使得一个算术表达式在计算时,运算顺序往往因表达式的内容而定,不具规律性. 这样很难编写出统一的计算指令.使用逆波兰算法可以轻松解决.他的核心思想是将普通的中缀表达式转换为后缀表达式. 转换为后缀表达式的好处是:1.去除原来表达式中的括号,因为括号只指示运算顺序,不是完成计算必须的元素.2.使得运算顺序有规律可寻,计

栈实现逆波兰表达式

栈实现逆波兰表达式 2015-04-05 Lover雪儿 1 //逆波兰表达式 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <math.h> 5 #include <ctype.h> 6 7 #define STACK_INIT_SIZE 20 //初始栈大小 8 #define STACK_INCREMENT 10 //扩充栈时每次增加的内存 9 #define MAXBUFFER 10 //

逆波兰算法

这里先给出运算符的优先级,表中0级优先级最低,7级最高,如下: 优先级 0 1 2 3   4       5     6         7   运算符 #  ( , +- */      @~     !%^   ) 说明 第一.生成逆波兰表达式 首先构建一个存储器,另一个符号栈,存储器是从左向右储存数据,而符号栈则遵守后进先出的原则,计算表达式按从左至右的顺序扫描. * 读入一个数据(重点注意:数值与函数名非单个字符,需要做判断处理) 1. 如果是左单目运算符或者函数名,直接入符号栈:比如

栈应用——逆波兰式表达式的值

问题描述: 计算给定的逆波兰表达式(即后缀表达式)的值. 事实上,二元运算的前提下,中缀表达式可以对应一棵二叉树:逆波兰式即该二叉树后序遍历的结果. 分析思路: 如果当前是操作数,则直接入栈: 如果当前是操作符,则栈顶的两个元素弹出,然后与当前操作符运算后入栈. Code: /** * 给出一个逆波兰式,计算该表达式的值 * @param s * @return */ public int getTheValueOfRPN(String s) { char[] ch = s.toCharArra

逆波兰算法~简单理解栈

#include <iostream> #include <stack> #include <string> using namespace std; int main() { stack<int> st;//初始化栈 string s; cin>>s; int x,y; for(int i=0;i<s.size();i++) { if(s[i]=='+') { x=st.top();//返回头部值 st.pop();//弹出 y=st.t

栈的应用---用栈计算逆波兰表达式

#include<stdio.h> #include<stdlib.h> struct Node; typedef struct Node *PtrToNode; typedef PtrToNode Stack; struct Node{ int Ele; PtrToNode Next; }; Stack CreateStack( void ) { Stack S; S = malloc( sizeof( struct Node ) ); if(S == NULL ) printf

栈之逆波兰

1 #include<stdio.h> 2 #include<stdio.h> 3 #include<stack> //queue 4 #include<string.h> 5 using namespace std; 6 stack<char> sck1; //cal 7 stack<char> sck2; //num 8 char ss[20]; 9 void transfer(char s[20],int n) 10 { 11

逆波兰算法,实现一个四则运算计算器

计算器分两步实现: 1.将常规表达式(中缀表达式)处理成后缀表达式. 2.计算后缀表达式. 第一步:  中缀如:1+(2*3)-4/2,转化为后缀123*+42/- . 规则:从左往右遍历中缀表达式,如果是数字,就直接拿出来,如果是符号,那么判断优先级,如果当前符号(包括右括号)的优先级不大于栈顶符号的优先级,那么依次出栈,直到优先级不满足(如果是右括号,那么直到出栈到左括号,后缀表达式里不需要左右括号),然后把该符号入栈.优先级高的直接入栈.如此直到搞定. 第二步: 计算后缀表达式. 规则:从