看大话数据结构 利用栈实现四则运算这一块儿正好是只有讲解没有代码实现的 于是照着书上的原理自己写了个四则运算的C#代码 以后可以考虑到作为自己的类库中的组件

主要涉及的是逆波兰式 程序主要部分为逆波兰式的产生 以及通过逆波兰式产生最终的四则运算结果

使用的时候只需输入四则运算的算是即可 如2*(1+2)+3*(4+5) 没有中括号大括号 程序会分三个步骤来 首先分割算式 将运算符与数字之间插入空格 方便之后的出入栈操作 如

2 * ( 1 + 2 ) +  3  * ( 4 + 5 )

之后将原式子转变为逆波兰式 最后通过逆波兰式生成最终的算术结果

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Class1
    {
        private static Dictionary<string, int> _operatorLevel;

        public static void Main(string[] arg)
        {
            Console.WriteLine("Type in the source expr");
            string sourceExpression = Console.ReadLine();
            Console.WriteLine(InsertBlank(sourceExpression));
            string rpnExperssion = ConvertToRPN(InsertBlank(sourceExpression));
            Console.WriteLine(rpnExperssion);
            Console.WriteLine(GetResult(rpnExperssion));
            Console.ReadLine();
        }

        public static double GetValue(double left, double right, char _operator)
        {
            switch (_operator)
            {
                case '+':
                    return left+right;
                case '-':
                    return left-right;
                case '*':
                    return left*right;
                case '/':
                    return left/right;
            }
            return 0;
        }

        public static double GetResult(string source)
        {
            Stack<string> stack = new Stack<string>();
            var list = source.Split(' ');
            for (int i = 0; i < list.Length; i++)
            {
                string current = list[i];
                if (Regex.IsMatch(current, "^([0-9]{1,}){1}quot;))
                {
                    stack.Push(current);
                }
                else if (OperatorLevel.ContainsKey(current))
                {
                    double right = double.Parse(stack.Pop());
                    double left = double.Parse(stack.Pop());
                    stack.Push(GetValue(left, right, current[0]).ToString());
                }
            }
            return double.Parse(stack.Pop());
        }

        public static string ConvertToRPN(string source)
        {
            StringBuilder result = new StringBuilder();
            Stack<string> stack = new Stack<string>();
            string[] list = source.Split(' ');
            for (int i = 0; i < list.Length ; i++)
            {
                string current = list[i];
                if (Regex.IsMatch(current, "^([0-9]{1,}){1}quot;))
                {
                    result.Append(current + " ");
                }
                else if (OperatorLevel.ContainsKey(current))
                {
                    if (stack.Count > 0)
                    {
                        var prev = stack.Peek();
                        if (prev == "(")
                        {
                            stack.Push(current);
                            continue;
                        }
                        if (current == "(")
                        {
                            stack.Push(current);
                            continue;
                        }
                        if (current == ")")
                        {
                            while (stack.Count > 0 && stack.Peek() != "(")
                            {
                                result.Append(stack.Pop() + " ");
                            }
                            //Pop the "("
                            stack.Pop();
                            continue;
                        }
                        if (OperatorLevel[current] < OperatorLevel[prev])
                        {
                            while (stack.Count > 0)
                            {
                                var top = stack.Pop();
                                if (top != "(" &&
                                    top != ")")
                                {
                                    result.Append(top + " ");
                                }
                                else
                                {
                                    break;
                                }
                            }
                            stack.Push(current);
                        }
                        else
                        {
                            stack.Push(current);
                        }
                    }
                    else
                    {
                        stack.Push(current);
                    }
                }
            }
            if (stack.Count > 0)
            {
                while (stack.Count > 0)
                {
                    var top = stack.Pop();
                    if (top != "(" && top != ")")
                    {
                        result.Append(top + " ");
                    }
                }
            }
            return result.ToString();
        }

        public static string InsertBlank(string source)
        {
            StringBuilder sb = new StringBuilder();
            var list = source.ToCharArray();
            foreach (var temp in list)
            {
                if (OperatorLevel.ContainsKey(temp.ToString()))
                {
                    sb.Append(" ");
                    sb.Append(temp.ToString());
                    sb.Append(" ");
                }
                else
                {
                    sb.Append(temp);
                }
            }
            return sb.ToString();
        }

//运算符字典 方便查询运算符优先级

        public static Dictionary<string, int> OperatorLevel
        {
            get
            {
                if(_operatorLevel==null)
                {
                    _operatorLevel = new Dictionary<string, int>();
                    _operatorLevel.Add("+", 0);
                    _operatorLevel.Add("-", 0);
                    _operatorLevel.Add("(", 1);
                    _operatorLevel.Add("*", 1);
                    _operatorLevel.Add("/", 1);
                    _operatorLevel.Add(")", 0);
                }
                return _operatorLevel;
            }
        }
    }
}