算法：中缀表达式转换为逆波兰表达式

背景

此文给出一个中缀表达式转变为逆波兰表达式（后缀表达式）的算法，算法实现的比较简单，特别是：词法分析部分是没有做的。

实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy.Stacks
{
    public static class Calculator
    {
        private static readonly Dictionary<string, int> _operators = new Dictionary<string, int>
        {
            { "+", 1 },
            { "-", 1 },
            { "*", 2 },
            { "/", 2 },
            { "%", 2 }
        };

        public static void Test(string expression)
        {
            foreach (var item in GetPostfixTokens(GetTokens(expression)))
            {
                Console.Write(item + " ");
            }
        }

        private static IEnumerable<string> GetPostfixTokens(IEnumerable<string> infixTokens)
        {
            var postfixTokens = new List<string>();
            var stack = new Stack<string>();

            foreach (var token in infixTokens)
            {
                if (IsOperator(token))
                {
                    var curOperator = token;

                    if (stack.Count == 0)
                    {
                        stack.Push(curOperator);
                    }
                    else
                    {
                        while (stack.Count != 0)
                        {
                            var popOperator = stack.Pop();
                            if (popOperator == "(")
                            {
                                stack.Push(popOperator);
                                break;
                            }

                            if (_operators[curOperator] <= _operators[popOperator])
                            {
                                postfixTokens.Add(popOperator);
                            }
                            else
                            {
                                stack.Push(popOperator);
                                break;
                            }
                        }

                        stack.Push(curOperator);
                    }
                }
                else if (token == "(")
                {
                    stack.Push(token);
                }
                else if (token == ")")
                {
                    var popOperator = stack.Pop();
                    while (popOperator != "(")
                    {
                        postfixTokens.Add(popOperator);
                        popOperator = stack.Pop();
                    }
                }
                else
                {
                    postfixTokens.Add(token);
                }
            }

            while (stack.Count != 0)
            {
                postfixTokens.Add(stack.Pop());
            }

            return postfixTokens;
        }

        private static IEnumerable<string> GetTokens(string expression)
        {
            var tokens = new List<string>();
            var sb = new StringBuilder();

            foreach (var item in expression)
            {
                if (IsOperator(item.ToString()) || item == '(' || item == ')')
                {
                    if (sb.Length > 0)
                    {
                        tokens.Add(sb.ToString());
                        sb.Clear();
                    }

                    tokens.Add(item.ToString());
                }
                else
                {
                    sb.Append(item);
                }
            }

            return tokens;
        }

        private static bool IsOperator(string token)
        {
            return _operators.ContainsKey(token);
        }
    }
}