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

算法

一、 将中缀表达式转换成后缀表达式算法：
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();
        }
    }
}

参考

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