数据结构&算法-逆波兰四则运算

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();
        }
    }
}

参考

链接:
逆波兰表达式
《大话数据结构》

以上是关于数据结构&算法-逆波兰四则运算的主要内容,如果未能解决你的问题,请参考以下文章

C语言 逆波兰表达式 算法

栈与队列应用:逆波兰计算器(逆波兰表达式;后缀表达式)把运算符放到运算量后边 && 中缀表达式转化为后缀表达式

北京大学 程序设计与算法逆波兰表达式

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

逆波兰算法

算法45----逆波兰数栈