none
大家看看我的这个C#,指点一下 RRS feed

  • 问题

  • 控制台代码已经写好,怎样改成winform形式呢?比如建立简单的窗体包含两个文本框和一个”计算“按钮,程序运行时,在其中一个文本框输入式子按“计算键后在另一个文本框显示结果。我觉得从理论上应该可以,因为这个算法知识通过控制台获得和输出数据,运算功能都是与控制台无关的,应该可以通过“txtBox.Text=”来实现吧?但是实际操作却老是出错。

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

    namespace SuperCalclulator
    {
        class Program
        {
            static void Main(string[] args)
            {
                List<SuperCalclu.ExpressionInput> Pre = new List<SuperCalclu.ExpressionInput>();
                List<SuperCalclu.ExpressionInput> RPN = new List<SuperCalclu.ExpressionInput>();
                string ss = Console.ReadLine();
                while (ss.Length != 0)
                {
                    Pre = SuperCalclu.Preprocess(ss);
                    //if (Pre[0].LB == SuperCalclu.Class.Error)
                    //{
                    //    Console.WriteLine("错误:{0}", Pre[0].Zhi);
                    //}
                    //else
                    //{
                    //    RPN = SuperCalclu.ToReversePolishNotation(Pre);   //Infixform(IFF)即中缀式ReversePolishNotation(RPN)即逆波兰式(后缀式)
                    //    for (int i = 0; i < RPN.Count; i++)
                    //    {
                    //        Console.Write(RPN[i].Zhi);
                    //        Console.Write(' ');
                    //    }
                    //    Console.Write("----");
                    //    Console.Write("结果:");
                    //    Console.Write(SuperCalclu.Calclulate(RPN));
                    //}
                    Console.WriteLine();
                    ss = Console.ReadLine();
                }
                Console.Read();
            }
        }
        class SuperCalclu
        {

            // 枚举表达式里面各数据的类别(数字,标识符,算符,左括号,右括号,错误)

            public enum Class { Number, NameMark, Operator, BracketsL, BracketsR, Error };

            // 表达式里面元素的结构(类型,值)

            public struct ExpressionInput
            {
                public Class LB;
                public string Zhi;
                public ExpressionInput(Class lb, string zhi)
                {
                    this.LB = lb;
                    this.Zhi = zhi;
                }
            };

            // 比较2个算符的优先级Priority

            public static char ComparePriority(string ch1, string ch2)
            {
                int i = Priority(ch1);
                int j = Priority(ch2);
                if (i < j)
                {
                    return '<';
                }
                else if (i == j)
                {
                    return '>';
                }
                else
                {
                    return '>';
                }
            }

            /// 取得单个字符的优先级
          
            public static int Priority(string ch)
            {
                switch (ch)
                {
                    case "+": return 1;
                    case "-": return 1;
                    case "*": return 2;
                    case "/": return 2;
                    case "div": return 2;
                    case "mod": return 2;
                    default: return 0;
                }
            }

            /// 给字符分类(数字,字母,算符,左括号,右括号,错误)

            public static char CharacterCheck(char c)
            {
                int unicode = Convert.ToInt16(c);
                if (unicode >= 48 && unicode <= 58)
                {
                    return 'D';//数字
                }
                else if (unicode >= 65 && unicode <= 90)
                {
                    return 'L';//字母
                }
                else if (unicode >= 97 && unicode <= 122)
                {
                    return 'L';//字母
                }
                else if (unicode == '+' || unicode == '-' || unicode == '*' || unicode == '/' || unicode == '%' || unicode == '$')
                {
                    return 'F';//算符
                }
                else if (unicode == '(')
                {
                    return '(';
                }
                else if (unicode == ')')
                {
                    return ')';
                }
                else
                {
                    return 'E';//错误
                }
            }

            // 预处理Preprocess

            public static List<ExpressionInput> Preprocess(string Infixform)
            {
                List<ExpressionInput> LHandle = new List<ExpressionInput>();
                if (Infixform.Length == 0)
                {
                    ExpressionInput ys = new ExpressionInput(Class.Error, "空串");
                    LHandle.Add(ys);
                    return LHandle;
                }
                //预处理中缀表达式字符串
                if (Infixform.Contains("mod"))
                {//把“mod”替换成“%”
                    Infixform = Infixform.Replace("mod", "%");
                }
                if (Infixform.Contains("div"))
                {//把“div”替换成“$”
                    Infixform = Infixform.Replace("div", "$");
                }

                char Ctemp = ' ';
                string Stemp = " ";
                int AlgLength = Infixform.Length;//表达式的长度
                Stack<Char> CStack = new Stack<char>();//用于检查括号是否匹配

                #region for循环开始

                for (int i = 0; i < AlgLength; i++)
                {
                    Ctemp = Infixform[i];
                    Stemp = "";

                    #region switch-case开始

                    switch (CharacterCheck(Ctemp))
                    {
                        case 'D':
                            {
                                do
                                {
                                    Stemp += Ctemp;
                                    if (i == AlgLength - 1)
                                    {
                                        break;
                                    }
                                    i++;
                                    Ctemp = Infixform[i];
                                } while (CharacterCheck(Ctemp) == 'D');
                                ExpressionInput ys = new ExpressionInput(Class.Number, Stemp);
                                LHandle.Add(ys);
                                if (CharacterCheck(Ctemp) != 'D')
                                {
                                    if (CharacterCheck(Ctemp) == 'L')
                                    {
                                        ExpressionInput yse = new ExpressionInput(Class.Error, "错误的数字组合在位置" + i.ToString());
                                        List<ExpressionInput> Error = new List<ExpressionInput>();
                                        Error.Add(yse);
                                        return Error;
                                    }
                                    i--;
                                }
                                break;
                            }
                        case 'L':
                            {
                                do
                                {
                                    Stemp += Ctemp;
                                    if (i == AlgLength - 1)
                                    {
                                        break;
                                    }
                                    i++;
                                    Ctemp = Infixform[i];
                                } while (CharacterCheck(Ctemp) == 'L' || CharacterCheck(Ctemp) == 'D');
                                ExpressionInput ys = new ExpressionInput(Class.NameMark, Stemp);
                                LHandle.Add(ys);
                                if (CharacterCheck(Ctemp) != 'L')
                                {
                                    i--;
                                }
                                break;
                            }
                        case 'F':
                            {
                                if (i == 0 || i == AlgLength - 1)
                                {
                                    ExpressionInput yse = new ExpressionInput(Class.Error, "错误的算符位置在" + i.ToString());
                                    List<ExpressionInput> Error = new List<ExpressionInput>();
                                    Error.Add(yse);
                                    return Error;
                                }
                                if (CharacterCheck(Infixform[i + 1]) == 'F' || CharacterCheck(Infixform[i + 1]) == ')')
                                {
                                    ExpressionInput yse = new ExpressionInput(Class.Error, "错误的算符位置在" + i.ToString());
                                    List<ExpressionInput> Error = new List<ExpressionInput>();
                                    Error.Add(yse);
                                    return Error;
                                }
                                ExpressionInput ys = new ExpressionInput(Class.Operator, Ctemp.ToString());
                                if (Ctemp == '%')
                                {
                                    ys.Zhi = "mod";
                                }
                                if (Ctemp == '$')
                                {
                                    ys.Zhi = "div";
                                }
                                LHandle.Add(ys);
                                break;
                            }
                        case '(':
                            {
                                CStack.Push('(');
                                ExpressionInput ys = new ExpressionInput(Class.BracketsL, "(");
                                LHandle.Add(ys);
                                break;
                            }
                        case ')':
                            {
                                if (CStack.Count == 0)
                                {
                                    ExpressionInput yse = new ExpressionInput(Class.Error, "括号不匹配");
                                    List<ExpressionInput> Error = new List<ExpressionInput>();
                                    Error.Add(yse);
                                    return Error;
                                }
                                else
                                {
                                    CStack.Pop();
                                }
                                ExpressionInput ys = new ExpressionInput(Class.BracketsR, ")");
                                LHandle.Add(ys);
                                break;
                            }
                        default:
                            {
                                ExpressionInput ys = new ExpressionInput(Class.Error, "表达式里有不合法的字符在位置" + i.ToString());
                                List<ExpressionInput> Error = new List<ExpressionInput>();
                                Error.Add(ys);
                                return Error;
                            }
                    }
                    #endregion
                }
                #endregion

                if (CStack.Count != 0)
                {
                    ExpressionInput ys = new ExpressionInput(Class.Error, "括号不匹配");
                    List<ExpressionInput> Error = new List<ExpressionInput>();
                    Error.Add(ys);
                    return Error;
                }

                return LHandle;
            }
            /// <summary>
            /// 中缀式转后缀式
            /// 将中缀表达式转换为后缀表达式的算法思想: 
            ///·当读到数字直接送至输出队列中 
            ///·当读到运算符t时, 
            ///a.将栈中所有优先级高于或等于t的运算符弹出,送到输出队列中; 
            ///b.t进栈 
            ///·读到左括号时总是将它压入栈中 
            ///·读到右括号时,将靠近栈顶的第一个左括号上面的运算符全部依次弹出,送至输出队列后,再丢弃左括号。
            public static List<ExpressionInput> ToReversePolishNotation(List<ExpressionInput> LHandle)
            {
                List<ExpressionInput> ReversePolishNotation = new List<ExpressionInput>();
                if (LHandle[0].LB == Class.Error)
                {
                    ExpressionInput ys = new ExpressionInput(Class.Error, "错误的表达式");
                    ReversePolishNotation.Add(ys);
                    return ReversePolishNotation;
                }
                Stack<ExpressionInput> NewStack = new Stack<ExpressionInput>();
                string SOperatorNow = "";
                string SOperatorSTop = "";
                #region for循环开始
                for (int i = 0; i < LHandle.Count; i++)
                {
                    #region switch-case开始
                    switch (LHandle[i].LB)
                    {
                        case Class.Number:
                        //{
                        //    ReversePolishNotation.Add(LHandle[i]);
                        //    break;
                        //}
                        case Class.NameMark:
                            {
                                ReversePolishNotation.Add(LHandle[i]);
                                break;
                            }
                        case Class.Operator:
                            {
                                if (NewStack.Count == 0)
                                {
                                    NewStack.Push(LHandle[i]);
                                    break;
                                }
                                while (NewStack.Count != 0)
                                {
                                    SOperatorNow = LHandle[i].Zhi;
                                    SOperatorSTop = NewStack.Peek().Zhi;
                                    if (ComparePriority(SOperatorSTop, SOperatorNow) == '>')
                                    {
                                        ReversePolishNotation.Add(NewStack.Pop());
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                                NewStack.Push(LHandle[i]);
                                break;
                            }
                        case Class.BracketsL:
                            {
                                NewStack.Push(LHandle[i]);
                                break;
                            }
                        case Class.BracketsR:
                            {
                                while (NewStack.Count != 0 && NewStack.Peek().LB != Class.BracketsL)
                                {
                                    ReversePolishNotation.Add(NewStack.Pop());
                                }
                                if (NewStack.Count != 0)
                                {
                                    NewStack.Pop();
                                }
                                break;
                            }
                    }
                    #endregion
                }
                #endregion
                while (NewStack.Count != 0)
                {
                    ReversePolishNotation.Add(NewStack.Pop());
                }
                return ReversePolishNotation;
            }

            /// 计算后缀式的值

            public static Double Calclulate(List<ExpressionInput> ReversePolishNotation)
            {
                Stack<double> Calclu = new Stack<double>();
                for (int i = 0; i < ReversePolishNotation.Count; i++)
                {
                    switch (ReversePolishNotation[i].LB)
                    {
                        case Class.Number:
                            {
                                Calclu.Push(Convert.ToDouble(ReversePolishNotation[i].Zhi));
                                break;
                            }
                        case Class.NameMark:
                            {
                                Calclu.Push(0);
                                break;
                            }
                        case Class.Operator:
                            {
                                double Result;
                                if (SiZeYunSuan(Calclu.Pop(), Calclu.Pop(), ReversePolishNotation[i].Zhi, out Result))
                                {
                                    Calclu.Push(Result);
                                    break;
                                }
                                else
                                {
                                    Console.WriteLine("不能除0");
                                    return 0;
                                }
                            }
                    }
                }
                return Calclu.Pop();
            }

            /// 四则运算操作数a,b,运算符sf,结果c

            public static bool SiZeYunSuan(double a, double b, string sf, out double c)
            {
                switch (sf)
                {
                    case "+": c = b + a; return true;
                    case "-": c = b - a; return true;
                    case "*": c = b * a; return true;
                    case "div":
                    case "/":
                        {
                            if (a != 0)
                            {
                                c = b / a;
                                return true;
                            }
                            else
                            {
                                c = 0;
                                return false;
                            }
                        }
                    case "mod":
                        {
                            if (a != 0)
                            {
                                c = b % a;
                                return true;
                            }
                            else
                            {
                                c = 0;
                                return false;
                            }
                        }
                    default: c = 0; return false;
                }
            }
        }
    }

    • 已更改类型 御微风 2013年7月13日 15:32
    2013年7月13日 15:29