/// <summary>
/// 使用逆波兰表示法求四则混合运算
/// 首先，需要两个栈
/// 栈s1用于临时存储运算符（含一个结束符号），此运算符在栈内遵循越往栈顶优先级越高的原则；
/// 栈s2用于输入逆波兰式；
/// 为方便起见，栈s1需要放入一个优先级最低的运算符，在这里假定为“#”；
/// 读取运算式入栈的步骤
/// 1.若x是操作数，则分析出完整的运算数，压入栈s2；
/// 2.若x是运算符，则分情况而定：
///   若x是‘（’，则直接压入栈s1
///   若x是‘）’，则将距离栈s1栈顶的最近的‘（’之间的运算符，逐个出栈，依次压入栈s2，此时抛弃‘（’
///   若x是除了‘（’和‘）’以外的运算符，则再分如下情况
///      若当前的栈顶元素是‘（’，则直接将x压入栈s1
///      若当前的栈顶元素不是‘（’，则将x与栈s1的栈顶元素进行对比，如果优先级比较高，则压入栈，如果优先级低，则把栈s1的栈顶元素弹出压入栈s2，直到栈s1的栈顶元素优先级低于x，
///      或则栈s2的栈顶运算符为‘（’，此时再将x压入栈s1
/// 3.进行完以上操作之后，检查栈s1是否为空，若不为空，则将栈中元素依次弹出并压入栈s2中。
/// </summary>

        //
        //判断是操作数还是操作符
        //
        static bool IsNumber(string str)
        {
            if (str == "(" || str == ")" || str == "*" || str == "/" || str == "-" || str == "+")
                return false;
            else
                return true;
        }

        //
        //定义优先等级，数字越大，优先等级越高
        //
        static void DefinePriority()
        {
            Dictionary<string, int> dic = new Dictionary<string, int>();
            dic.Add("(", 7);
            dic.Add(")", 6);
            dic.Add("*", 5);
            dic.Add("/", 5);
            dic.Add("-", 4);
            dic.Add("+", 4);
            dic.Add("#", 3);
        }

        //
        //接受一个字符串数组，转逆波兰式子
        //
        public void ReverseToPolish(string[] str)
        {
            
            stack1.Push("#");                                   //栈1压入#
            if (str != null)                                    //如果字符串数组不为空，执行判断
            {
                //因为是处理栈堆，很容易出现内存分配读取异常，加一个try catch
                try
                {
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (IsNumber(str[i]))                       //如果是数字，直接压入栈2
                            stack2.Push(str[i]);
                        else
                        {
                            if (dic[str[i]] == 7)                      //如果是“（”,直接压入栈1
                            {
                                stack1.Push(str[i]);
                            }
                            else if (dic[str[i]] == 6)               //如果是“)”,将栈顶元素依次压入栈2，直到遇到“（”
                            {
                                while (stack1.Peek() != "(")
                                {
                                    stack2.Push(stack1.Pop());
                                }
                                stack1.Pop();                       //移除栈顶元素“（”
                            }
                            else if (dic[str[i]] == 5 || dic[str[i]] == 4)    //除了“（”和“）”的情况                             
                            {
                                if (stack1.Peek() == "(")              //如果栈顶元素是“（”，直接压入栈1
                                {
                                    stack1.Push(str[i]);
                                }
                                //若当前的栈顶元素不是‘（’，则将x与栈s1的栈顶元素进行对比，如果优先级比较高，则压入栈
                                //如果不是，则把栈s1的栈顶元素弹出压入栈s2，直到栈s1的栈顶元素优先级低于x
                                else
                                {
                                    while (dic[str[i]] <= dic[stack1.Peek()])   //如果优先等级不高于栈顶
                                    {
                                        stack2.Push(stack1.Pop());
                                    }
                                    stack1.Push(str[i]);
                                }
                            }//end else if
                        }//end else
                    }//end for
                     //进行完以上操作，检查栈1是否为“#”，不是，则把栈顶元素依次压入栈2
                    while (stack1.Peek() != "#")
                    {
                        stack2.Push(stack1.Pop());
                    }
                }
                catch
                {
                    stack2.Push("0");
                }

            }
            //检查下是否正确
            foreach (var item in stack2)
                Console.Write(item);
            Console.WriteLine();

        }