• c# 堆栈四则运算


    public static Double GetResultFromStr(string source)
           {
               string str = InsertBlank(source);
               string rpnExperssion = ConvertToRPN(str);
               return GetResult(rpnExperssion);
    
           }
      
            private 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;  
            }
    
            private static double GetResult(string source)  
            {
                try
                {
                    source = source.Trim();
                    Stack<string> stack = new Stack<string>();
                    var list = source.Split(' ');
                    for (int i = 0; i < list.Length; i++)
                    {
                        string current = list[i];
                        //bool  b = Regex.IsMatch(strNum, "^[0-9]*{1}quot;);  
                        if (GetNum(current))
                        {
                            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());
                        }
                    }
                    string aaa = stack.Pop().ToString();
                    return double.Parse(aaa);
                }
                catch (Exception e)
                { }
                return 0;
            }
    
            private static string ConvertToRPN(string source)  
            {
                try
                {
                    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;"))
                        if (GetNum(current))
                        {
                            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().Trim();
                }
                catch(Exception e)
                { }
                return "";
            }
    
            private 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();          }
    
            private 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;  
                }  
            }  
    
               /// <summary>  
           /// 验证是不是数字(包含整数和小数)  
           /// </summary>  
           /// <param name="str"></param>  
           /// <returns></returns>  
           private static bool GetNum(string str)  
           {
               bool b = false;
               try
               {
                   double.Parse(str);
                   b = true;
               }
               catch (Exception e)
               { 
    
               }
               return b;
          }  
    View Code
  • 相关阅读:
    Hadoop实战课程
    R语言实战读书笔记(七)基本统计分析
    R语言实战读书笔记(六)基本图形
    python-unexpected content storage modification出错
    python——no module named XX
    R语言实战读书笔记(五)高级数据管理
    R语言缺失值信息处理
    R语言,NA,NAN
    R语言实战读书笔记(四)基本数据管理
    R语言实战读书笔记(三)图形初阶
  • 原文地址:https://www.cnblogs.com/chengjunwei/p/4332608.html
Copyright © 2020-2023  润新知