VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > 编程开发 > C#编程 >

  • C#教程之C#利用栈实现加减乘除运算

本站最新发布   C#从入门到精通
试听地址  https://www.xin3721.com/eschool/CSharpxin3721/

还是有一些小问题....懒得改了，但大体思路还是清晰的，首先定义一个运算符栈，一个数栈。

关于优先级，两个括号(，)优先级最低，其次是+、-,最高的是*、/

关于运算法则，打个比方，"(3+5*4)+3"这个串

首先遇到左括号，直接压入运算符栈，然后是3，直接压入数栈，然后遇到5，压入数栈，遇到*，将其压入运算符栈，遇到右括号，将运算符栈顶的*取出，取出两个数栈栈顶的数，进行乘法运算，将运算结果压入数栈，因为此时运算符栈顶仍不是左括号，取出栈顶的+号，拿出数栈栈顶的两个数，进行加法运算，并将结果压入数栈。此时栈顶是左括号了，那么将左括号弹出栈。此时数栈里还有一个23，运算符栈为空。接着来。此时轮到了+号，直接压入数栈，遇到3，直接压入数栈。此时发现串已经结尾了，但是运算符栈还没有清空。那么就清空吧，把+号拿出来，数栈的23和3拿出来，加法运算，结果压入数栈。此时运算符栈清空，数栈剩个26。这就是最后的结果。是不是很简单但是有一点云里雾里。。

说一下运算规则吧。优先级大家都知道了，优先级从高到低依次是 "*/","+-","()"，每当要压运算符时，首先得看看运算符栈里有什么，如果没有，肯定是可以直接压入的，左括号也是可以不管三七二十一直接压入的，除此之外，如果遇到栈顶运算符优先级更高时，是必须将栈顶运算符先取出来运算，直到栈顶元素优先级小于或者等于要压入的运算符的优先级才可压入。比如3*5+5+5，在压入第一个+号时，必须先将栈里的*号先拿出来运算结束后，才能放进去，否则计算结果将是错误的。当压入的是右括号时，必须一直弹运算符栈进行运算，直到遇到左括号为止。当串扫描到末尾时，也必须将运算符栈清空，最后留在数栈的数就是结果。关于小数点，关于复数加减运算，我写的小程序里有了一定的处理

就类似于这样的简单功能。。。。恩，将就看看吧。。程序不完善，不过也懒得改了，毕竟是练习，最近事又多。

下面贴一下源码

主要用到的几个类和方法:

   类Parser   的parse方法，比如给一个“3+4i”的字符串，返回给你一个3个结点的队，队列第一个元素是一个ComplexNumber对象，实数域为3，队列的第二个元素是“+”号，队列第三个元素是一个ComplexNumber对象，实数域为0,虚数域为4。

    类Operators    用于测试字符是否是运算符，用来进行控制运算，比较运算符优先级....

    类Handler   给一个字符串，他帮你处理，返回给你一个结果。其实就是调一下Parser类的方法去解析一下字符串，然后算一下结果，然后返回结果。

 类ComplexNumber，就是复数类啊，不用说了，提供实数域虚数域，getset方法，加减乘除以及toString()方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
using System;
using System.Collections;
using System.Text;
namespace MySpace{
    class Parser{
        public static Queue Parse(string input){
            char[] arr = input.ToCharArray();
            Queue queue = new Queue();
            foreach(char x in arr){
                queue.Enqueue(x);
            }
            queue = ParseStringQueue(queue);
            return queue;
        }
        
        //传入字符串队列，返回封装好的队列。
        //ComplexNumber对象或char类型运算符各占用一个结点
        private static Queue ParseStringQueue(Queue queue){
            Queue secondQ = new Queue();
            char c;
            StringBuilder sb = null;
            string temp;
            int count = queue.Count;
            bool flag = false; //false表示允许创建新SB对象进行缓存数字字符串
            for(int i=0;i<count;i++){
                c = (char)queue.Dequeue();
                
                if(!Operators.Contains(c)){
                    //如果扫描到的不是运算符，则将其加入到buffer尾部
                    if(!flag){
                        flag = true;
                        sb = new StringBuilder();
                    }
                    sb.Append(c);
                }
                if(Operators.Contains(c) || queue.Count == 0){
                    //如果扫描到的是运算符，则将缓冲区中的串加入队尾
                    if(sb != null && flag == true){
                        temp = sb.ToString();
                        try{
                            if(temp.EndsWith("i")){
                                    if(temp.Length==1){
                                        secondQ.Enqueue(new ComplexNumber(0,1));
                                    }else{
                                    //i前有数字则开出数字部分。
                                        temp = temp.Substring(0,temp.Length-1);
                                        secondQ.Enqueue(new ComplexNumber(0,double.Parse(temp)));
                                    }
                                
                            }else{
                                secondQ.Enqueue(new ComplexNumber(double.Parse(temp),0));
                            }
                            sb = null;
                            flag = false;
                        }catch(Exception e){
                            Console.WriteLine("Error");
                        }
                    }
                    //如果是运算符，则最后将运算符放入队。
                    if(Operators.Contains(c)){
                        secondQ.Enqueue(c);
                    }
                }
            }
            
            return secondQ;
        }
    }
    class ComplexNumber{
        private double m_dRealPart;
        private double m_dImaginPart;
        public ComplexNumber(){
            m_dRealPart = 0.0;
            m_dImaginPart = 0.0;
        }
        public ComplexNumber(double r,double i){
            m_dRealPart = r;
            m_dImaginPart = i;
        }
        public ComplexNumber(ComplexNumber c){
            m_dRealPart = c.GetRealPart();
            m_dImaginPart = c.GetImaginaryPart();
        }
        //get,set方法
        public double GetRealPart(){
            return m_dRealPart;
        }
        public double GetImaginaryPart(){
            return m_dImaginPart;
        }
        public void SetRealPart(double d){
            m_dRealPart = d;
        }
        public void SetImaginaryPart(double d){
            m_dImaginPart = d;
        }
        public ComplexNumber ComplexAdd(ComplexNumber c){
            return new ComplexNumber(this.m_dRealPart + c.GetRealPart(),this.m_dImaginPart + c.GetImaginaryPart());
        }
        public ComplexNumber ComplexAdd(double c){
            return new ComplexNumber(
            this.m_dRealPart + c, 
            this.m_dImaginPart);
        }
        
        public ComplexNumber ComplexMinus(ComplexNumber c){
           return new ComplexNumber(this.m_dRealPart - c.GetRealPart(),this.m_dImaginPart - c.GetImaginaryPart());
        }
        public ComplexNumber ComplexMinus(double c){
            return new ComplexNumber(this.m_dRealPart - c, this.m_dImaginPart);
        }
        //乘
        public ComplexNumber ComplexMulti(ComplexNumber c){
            return new ComplexNumber(
            this.m_dRealPart * c.GetRealPart() 
            - this.m_dImaginPart * c.GetImaginaryPart(),
            this.m_dRealPart * 
            c.GetImaginaryPart()
            + this.m_dImaginPart * 
            c.GetRealPart());
        }
        public ComplexNumber ComplexMulti(double c){
            return
                new ComplexNumber(
                    this.m_dRealPart * c,
                    this.m_dImaginPart * c);   
        }
        //除
        public ComplexNumber ComplexDivision(ComplexNumber c){
            return
                new ComplexNumber((this.m_dRealPart*c.GetRealPart()
                +this.m_dImaginPart*c.GetImaginaryPart())/(c.GetRealPart()*c.GetRealPart()+c.GetImaginaryPart()*c.GetImaginaryPart())
                ,(this.m_dImaginPart*c.GetRealPart()-this.m_dRealPart*c.GetImaginaryPart())
                /(c.GetRealPart()*c.GetRealPart()+c.GetImaginaryPart()*c.GetImaginaryPart())); 
        }
        public ComplexNumber ComplexDivision(double c){
            return new
                ComplexNumber(this.m_dRealPart/c,this.m_dImaginPart/c);
        }
    
        public override String ToString(){
           return "(" + m_dRealPart + " + " + m_dImaginPart + " i" + ")";
        }
    }
    class Operators{
        static char[][] signOperator;
        
        static Operators(){
            signOperator = new char[3][];
            signOperator[0] = new char[2];
            signOperator[0][0]='*';
            signOperator[0][1]='/';
            signOperator[1] = new char[2];
            signOperator[1][0]='+';
            signOperator[1][1]='-';
            signOperator[2] = new char[2];
            signOperator[2][0]='(';
            signOperator[2][1]=')';
        }
        
        public static int ComparePriority(char firstSign,char secondSign){
            int priorityF = 0,priorityS = 0;
            for(int i = 0; i<signOperator.Length;i++){
                foreach(char x in signOperator[i]){
                    if(firstSign == x){
                        priorityF = i;
                    }
                    if(secondSign == x){
                        priorityS = i;
                    }
                }
            }
            
            return (priorityF-priorityS);
        }
        
        public static bool Contains(char x){
            foreach(char[] arr in signOperator){
                foreach(char y in arr){
                    if(x == y){
                        return true;
                    }
                }
            }
            return false;
        }
        
        public static ComplexNumber Compute(char ope,ComplexNumber c1,ComplexNumber c2){
            ComplexNumber result = null;
            switch(ope){
                case '+':result=c1.ComplexAdd(c2);break;
                case '-':result=c2.ComplexMinus(c1);break;
                case '*':result=c1.ComplexMulti(c2);break;
                case '/':result=c1.ComplexDivision(c2);break;
            }
            return result;
        }
    }
    
    class Handler{
        private Stack complexNumberStack = new Stack();
        private Stack operatorStack = new Stack();
        private static Handler handler = new Handler();
        private Handler(){}
        public static Handler GetHandler(){
            return handler;
        }
    
        public ComplexNumber Process(string inputString){
            Queue queue = Parser.Parse(inputString);
            ComplexNumber complexNumber = null;
            char c,top,ct;
            int count = queue.Count;
            for(int i=0;i<count;i++){
                Object obj = queue.Dequeue();
                if(obj is char){
                    c = (char)obj;
                    if(operatorStack.Count == 0){
                        operatorStack.Push(c);
                    }else{
                        top = (char)operatorStack.Peek();
                        if(c=='('){
                            operatorStack.Push(c);  //左括号直接压入。不判断栈顶
                        }else if(c==')'){  
                        //右括号压入前观察栈顶，若栈顶是左括号，则弹出栈顶的左括号
                        //否则弹出栈顶运算符，从数栈中弹出操作数进行运算，并将结果重新压入数栈，直到遇到左括号
                            while((ct=(char)operatorStack.Pop())!='('){
                                ComplexNumber c1 = (ComplexNumber)complexNumberStack.Pop();
                                ComplexNumber c2 = (ComplexNumber)complexNumberStack.Pop();
                                ComplexNumber c3 = Operators.Compute(ct,c1,c2);
                                complexNumberStack.Push(c3);
                            }
                        }else if(Operators.ComparePriority(top,c)<0){
                            //若即将压入的运算符不是括号，则比较栈顶运算符和即将压入的运算符的优先级
                            //如果栈顶优先级高，则将栈顶运算符取出运算，直到栈顶优先级不大于其。
                            while(Operators.ComparePriority((char)operatorStack.Peek(),c)<0){
                                ComplexNumber c1 = (ComplexNumber)complexNumberStack.Pop();
                                ComplexNumber c2 = (ComplexNumber)complexNumberStack.Pop();
                                ComplexNumber c3 = Operators.Compute((char)operatorStack.Pop(),c1,c2);
                                complexNumberStack.Push(c3);
                                operatorStack.Push(c);
                            }
 
 
                        }else{
                            operatorStack.Push(c);
                        }
                    }
                }else if(obj is ComplexNumber) {
                    complexNumber = (ComplexNumber)obj;
                    complexNumberStack.Push(complexNumber);
                }
                
                if(queue.Count == 0){
                    if(operatorStack.Count != 0){
                        while(operatorStack.Count != 0){                               
                            c = (char)operatorStack.Pop();
                            ComplexNumber c1 = (ComplexNumber)complexNumberStack.Pop();
                            ComplexNumber c2 = (ComplexNumber)complexNumberStack.Pop();
                            ComplexNumber c3 = Operators.Compute(c,c1,c2);
                            complexNumberStack.Push(c3);
                        }
                    }
                }
            }
            
            return (ComplexNumber)complexNumberStack.Pop();
        }
    }
    class PrimeClass{
        static void Main(string[] args){
            String input;
            Handler handler = Handler.GetHandler();
            while(!(input = Console.ReadLine()).Equals("END")){
                ComplexNumber c = (ComplexNumber)handler.Process(input);
                Console.WriteLine(c);
            };
        }
    }
    
}
相关教程