数据结构&算法-逆波兰四则运算
Posted 彩色墨水
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构&算法-逆波兰四则运算相关的知识,希望对你有一定的参考价值。
算法
一、 将中缀表达式转换成后缀表达式算法:
1、从左至右扫描一中缀表达式。
2、若读取的是操作数,则判断该操作数的类型,并将该操作数存入操作数堆栈
3、若读取的是运算符
(1) 该运算符为左括号"(",则直接存入运算符堆栈。
(2) 该运算符为右括号")",则输出运算符堆栈中的运算符到操作数堆栈,直到遇到左括号为止。
(3) 该运算符为非括号运算符:
(a) 若运算符堆栈栈顶的运算符为括号,则直接存入运算符堆栈。
(b) 若比运算符堆栈栈顶的运算符优先级高或相等,则直接存入运算符堆栈。
© 若比运算符堆栈栈顶的运算符优先级低,则输出栈顶运算符到操作数堆栈,并将当前运算符压入运算符堆栈。
4、当表达式读取完成后运算符堆栈中尚有运算符时,则依序取出运算符到操作数堆栈,直到运算符堆栈为空。
二、逆波兰表达式求值算法:
1、循环扫描语法单元的项目。
2、如果扫描的项目是操作数,则将其压入操作数堆栈,并扫描下一个项目。
3、如果扫描的项目是一个二元运算符,则对栈的顶上两个操作数执行该运算。
4、如果扫描的项目是一个一元运算符,则对栈的最顶上操作数执行该运算。
5、将运算结果重新压入堆栈。
6、重复步骤2-5,堆栈中即为结果值。
运行结果
代码
using System;
using System.Collections.Generic;
namespace ReversePolish
{
class Program
{
static void Main(string[] args)
{
string calcmode = "2.5+3*4-5*2+(15-9)/2";
ReversePolishC polishC = new ReversePolishC();
polishC.CalcTarget(calcmode);
}
}
//先后缀表达式
//再入栈计算
class ReversePolishC
{
public float CalcTarget(string arg)
{
return CalcReversePolish(midToLastMode(arg));
}
/// <summary>
/// 中缀表达式转为后缀表达式
/// </summary>
/// <param name="arg">中缀表达式</param>
/// <returns></returns>
public List<string> midToLastMode(string arg)
{
List<string> suffixMode = new List<string>();
Stack<string> stack = new Stack<string>();
string numstr = "";
for (int i = 0; i < arg.Length; i++)
{
if (char.IsNumber(arg[i]) || arg[i] == '.')//数字
{
numstr += arg[i];
}
else if (arg[i].Equals('('))//括号
{
if (numstr != "")
{
suffixMode.Add(numstr);
numstr = "";
}
stack.Push(arg[i].ToString());
}
else if (arg[i].Equals(')'))//括号
{
if (numstr != "")
{
suffixMode.Add(numstr);
numstr = "";
}
while (stack != null)
{
string temp = stack.Pop();
if (temp != "(")
{
suffixMode.Add(temp);
}
else
{
break;
}
}
}
else if (arg[i].Equals('*') || arg[i].Equals('/')) //乘除
{
if (numstr != "")
{
suffixMode.Add(numstr);
numstr = "";
}
while (true)
{
string temp;
if (stack.Count > 0)
{
temp = stack.Peek();
}
else
{
stack.Push(arg[i].ToString());
break;
}
if (temp == "*" || temp == "/")
{
suffixMode.Add(stack.Pop());
}
else
{
stack.Push(arg[i].ToString());
break;
}
}
}
else if (arg[i].Equals('+') || arg[i].Equals('-')) //加减
{
if (numstr != "")
{
suffixMode.Add(numstr);
numstr = "";
}
while (true)
{
string temp;
if (stack.Count > 0)
{
temp = stack.Peek();
}
else
{
stack.Push(arg[i].ToString());
break;
}
if (temp == "*" || temp == "/" || temp == "+" || temp == "-")
{
suffixMode.Add(stack.Pop());
}
else
{
stack.Push(arg[i].ToString());
break;
}
}
}
}
if (numstr != "")
{
suffixMode.Add(numstr);
numstr = "";
}
while (stack.Count > 0)
{
suffixMode.Add(stack.Pop());
}
//string target = "";
for (int i = 0; i < suffixMode.Count; i++)
{
Console.WriteLine(suffixMode[i]);
}
return suffixMode;
}
/// <summary>
/// 后缀表达式进行计算
/// </summary>
/// <param name="reversep"></param>
float CalcReversePolish(List<string> reversep)
{
Stack<float> stack = new Stack<float>();
float target;
for (int i = 0; i < reversep.Count; i++)
{
if (float.TryParse(reversep[i], out target))
{
stack.Push(target);
}
else if (reversep[i].Equals("*"))//乘
{
float tempA = stack.Pop();
float tempB = stack.Pop();
target = tempB * tempA;
stack.Push(target);
}
else if (reversep[i].Equals("/")) //除
{
float tempA = stack.Pop();
float tempB = stack.Pop();
target = tempB / tempA;
stack.Push(target);
}
else if (reversep[i].Equals("+")) //加
{
float tempA = stack.Pop();
float tempB = stack.Pop();
target = tempB + tempA;
stack.Push(target);
}
else if (reversep[i].Equals("-")) //减
{
float tempA = stack.Pop();
float tempB = stack.Pop();
target = tempB - tempA;
stack.Push(target);
}
}
Console.WriteLine("----------计算结果------------");
Console.WriteLine(stack.Peek());
return stack.Peek();
}
}
}
参考
以上是关于数据结构&算法-逆波兰四则运算的主要内容,如果未能解决你的问题,请参考以下文章