///<summary>
        ///处理正负号
         ///</summary>
        ///<param name="exp"></param>
        ///<returns></returns>
privatestaticstringFormatExp(stringexp)
        {
            var result =exp.Trim().Replace("", "");

if(result[0] =='+'||result[0] =='-')
            {
                result ="0"+result;
            }
            for(var i =0; i <result.Length -1; i++)
            {
                if(result[i] =='('&&(result[i +1] =='+'||result[i +1] =='-'))
                {
                    result =result.Substring(0, i +1) +"0"+result.Substring(i +1);
                }
            }

returnresult;
        }

///<summary>
        ///将解析过后的表达式转换为逆波兰表达式(各个语义单元存放在列表中)
        ///</summary>
        ///<param name="tokens"></param>
        ///<returns></returns>
privatestaticList<string>ToRPNExp(List<string>tokens)
        {
            var result =newList<string>();
            var opStack =newStack<string>();

opStack.Push("\0");

for(var i =0; i <tokens.Count; i++)
            {
                if(IsOperator(tokens[i]))
                    result.AddRange(HandleOperator(opStack, tokens[i]));
                elseresult.Add(tokens[i]);
            }

while(opStack.Peek() !="\0")
            {
                result.Add(opStack.Pop());
            }
            returnresult;
        }
        ///<summary>
        ///根据操作符的优先级决定入栈还是出栈
        ///</summary>
        ///<param name="st"></param>
        ///<param name="op"></param>
        ///<returns></returns>
privatestaticList<string>HandleOperator(Stack<string>st, stringop)
        {
            var result =newList<string>();

if(op =="(")
            {
                st.Push(op);
            }
            elseif(op ==")")
            {
                while(st.Peek() !="(")
                {
                    result.Add(st.Pop());
                }
                st.Pop();
            }
            else
            {
                var priority1 =IcpPriority[op];
                var priority2 =IspPriority[st.Peek()];

while(priority2 >=priority1)
                {
                    result.Add(st.Pop());
                    priority2 =IspPriority[st.Peek()];
                }
                st.Push(op);
            }
            returnresult;
        }

///<summary>
        ///进行计算
        ///</summary>
        ///<param name="tokens"></param>
        ///<returns></returns>
privatestaticdoubleDoCalc(List<string>tokens)
        {
            var st =newStack<double>();

foreach(var token intokens)
            {
                if(!IsOperator(token))
                {
                    //操作数入栈
st.Push(double.Parse(token));
                }
                else
                {
                    //操作符从栈顶取出两个元素进行计算，并将结果推入栈中
var operand1 =st.Pop();
                    var operand2 =st.Pop();

switch(token)
                    {
                        case"+":
                            st.Push(operand2 +operand1);
                            break;
                        case"-":
                            st.Push(operand2 -operand1);
                            break;
                        case"*":
                            st.Push(operand2 *operand1);
                            break;
                        case"/":
                            st.Push(operand2 /operand1);
                            break;
                        case"^":
                            st.Push(Math.Pow(operand2, operand1));
                            break;

}
                }
            }
            //最终栈顶元素即为表达式的值
returnst.Pop();
        }