数据结构课程设计逆波兰设计 报告+代码

1.实验内容与要求

  1.1 实验内容

     逆波兰表达式又叫做，是波兰逻辑学家 J・卢卡西维兹于 1929 年首先提出的 一种表达式的表示方法。采用这种表达式组织逻辑提问非常方便检索运算，所以这种方法最 早用于情报检索。不同于通常的中缀表达式，逆波兰表达式把操作数写在前面，操作符写在 后面，所以也称为后缀表达式。请采用相应的数据结构实现中缀表达式转换成逆波兰表达式， 并实现逆波兰表达式的计算，要求能够支持加、减、乘、除、取余、指数和括号等运算。

  1.2 实验要求

   

1. 要求采用链表来实现栈，不允许使用标准模板类的链表类(list)、栈类（stack）和函数；
2. 要求支持加、减、乘、除、取余、指数和括号等运算；
3. 实现中缀表达式转换成逆波兰表达式的功能时，要求输出显示能够清楚地显示出的整个 转换过程，包括压栈和出栈过程；
4. 实现逆波兰表达式的计算功能时，要求输出显示能够清楚地显示出的整个计算过程，包 括压栈和出栈过程；
5. 要求采用类的设计思路，不允许出现类以外的函数定义，但允许友元函数。主函数中只 能出现类的成员函数的调用，不允许出现对其它函数的调用。
6. 要求采用多文件方式：.h 文件存储类的声明，.cpp 文件存储类的实现，主函数 main 存 储在另外一个单独的 cpp 文件中。如果采用类模板，则类的声明和实现都放在.h 文件中。
7.  不强制要求采用类模板，也不要求采用可视化窗口；要求源程序中有相应注释；
8. 建议采用 Visual C 6.0 及以上版本进行调试； 

2.设计思路设计

   该设计主要分为两部分，一部分是实现中缀表达式转为后缀表达式；另一部分是实现后缀表达式的计算。实现第一个功能采用栈（存字符串）的结构，将输入的每个字符进行判断等操作，取用两个栈，一个存运算符，另一个存每一步转化过程的不完整表达式，最终输出结果。第二个功能也采用栈（存数字结果）的结构进行辅助，对每个输入的字符进行判断，将最终结果存入栈中

 2.1 系统总体设计

1. 利用链表的功能与定义，设计两个stack类，分别命名为Mystack 与Mystack1。将两个链表设计得与STL中的栈的功能大体相似，这两个栈的区别为，Mystack类存储数学结果（双精度浮点数），Mystack1类存储字符串。
2. 在实现后缀表达式的计算时，将输入的字符一个个进行判断，若判断为数字，将这个浮点数提取出来，再存入到Mystack类的栈中，若遇到运算字符，在栈取两个数任然不为空的情况下，取出两个浮点数，进行相应的运算操作，并且将新的结果压入栈中。

2.2 系统功能定义

2.3 算法设计 

   2.3.1计算后缀表达式

     首先采用流程图的形式描述算法，计算后缀表达式的流程如下图所示。

算法文字描述

首先我们需要一个stack类来存放我们一步步计算得到的结果，用链表来建立这个结构在实现计算后缀表达式的功能中，最重要的就是提取出输入的数字字符与运算符字符。该功能执行的第一步是初步判断输入的表达式是否含有除运算符、数字字符、空格和小数点之外的字符，如果存在这种不合法的字符，则立刻报错，不进行任何的计算（出栈、入栈等操作）。如果没有发现这样的字符，则开始计算。

   计算采用遍历判断结构，若判断出该字符是一个数字字符，则程序进行提取数字操作。具体实现过程为：

（1）若当前的字符任然为数字，则进行多位数提取操作（sum=sum*10 i类似这样的操作），继续往下遍历整个字符串，直到遇到字符不是数字和小数点的才停止。

1. 如果判断出当前的字符为小数点，则保持前面计算出的sum即小数点前的

数值不变，使用pow函数来进行小数点后的提取（若当前是小数点一位，则计算sum=sum pow(10,-pos)*i），持续做这样的操作，继续遍历字符串，直到遇到的字符不是数字字符为止（即该数字提取完毕）提取完毕数字之和，将数字的数值压入自己定义的栈中，等待计算。

如果当前的字符是运算符

1. case：“ ”遇到加号，对栈分别进行两次判断空操作，若提取两个数字仍不为空，则将这两个数进行加法运算，并将运算的结果存入栈中。若出现为空的情况，则程序报错，退出计算，并要求重新输入后缀表达式。
2. Case：“-”遇到减号，对栈分别进行两次判断空操作，若提取两个数字仍然不为空，则将这两个数进行减法运算，并将运算的结果存入栈中。若出现为空的情况，则程序报错，退出计算，并要求重新输入后缀表达式。
3. Case：“*”遇到乘号，对栈分别进行两次判断空操作，若提取两个数字仍然不为空，则将这两个数进行乘法运算，并将运算的结果存入栈中。若出现为空的情况，则程序报错，退出计算，并要求重新输入后缀表达式。
4. Case：“/”遇到除号，对栈分别进行两次判断空操作，若提取两个数字仍然不为空，并且除数不为0，则将这两个数进行除法运算，并将运算的结果存入栈中。若出现为空或者除数为0的情况，则程序报错，退出计算，并要求重新输入后缀表达式。
5. Case：“%”遇到取余符号，对栈分别进行两次判空操作，若提取两个数字仍然不为空，则将这两个数提取出来，提取之后，判断该数是否为整数，若这两个数都是整数，则进行取余运算，若有一个或者两个都是浮点数，则程序会进行提示小数无法进行取余运算，程序报错，退出计算，并要求重新输入后缀表达式
6. Case：“^”遇到取幂符号，对栈分别进行两次判空操作，若提取两个数字仍然不为空，则将这两个数进行取幂运算，并将运算的结果存入栈中。若出现为空的情况，则程序报错，退出计算，并要求重新输入后缀表达式。
7. Case：“ ”遇到空格的话，不进行任何多余的操作，直接continue

一个个判断，直到判断遍历字符串完成，得出一个最后的结果。当然，得到这个结果之后，还要对栈的size进行判断，如果后缀表达式输入无误的话，栈里面只有一个数值，若栈的size不为1，则可以断定输入的表达式是不合法的，则程序进行报错，结束计算，并要求重新输入后缀表达式。

  2.3.2 实现中缀表达式转后缀

下图为该功能的流程图

中缀转后缀算法文字描述

    报错机制（计算这个后缀表达式）

首先实现这个我们需要一个辅助站来存一个个字符，这里仍然使用链表，建立一个简单的stack类，与上面的很相似，只是存储的数据类型不一样。上面储存的是数值类型，这里储存的是字符类型。

运算符优先级 ^  > *  /  %  >    - 并且左括号等级最低。

该功能执行的第一步也是判断输入的字符串是否存在不合法的字符（除数字、运算符、空格、小数点、括号的字符）如果存在这样的不合法字符，程序直接提示错误，并且要求重新输入中缀表达式。如果该字符串合法的话，则开始执行中缀转后缀的操作。

转换操作总体结构就是遍历字符串。同时，这里需要两个stack类来作为辅助栈，一个存储遇到的符号，下面简称为符号栈。一个存储一步步得到的后缀表达式，下面简称为结果栈。

如果遇到的是数字字符，则开始提取数字的操作（即一个循环）。将数字字符压入栈中，往下继续遍历字符串，将该字符压入栈中，若遍历中遇到了一个不是小数点字符也不是数字字符的字符，就结束字符的入栈循环，并在结果栈中加入一个空格来分割这些表达式。

如果遇到的是运算符，则开始运算符优先级比较以及出栈、入栈操作。具体实现过程如下：

1. case：“(”如果遇到的是左括号，则将左括号压到符号栈中。
2. Case：“)”如果遇到的是右括号，则对符号栈里的符号进行遍历，持续弹出里面的运算符，直到遇到“(”为止，没遇到之前，一直持续弹出，并将这些元素全都压入结果栈中。
3. Case：“ ”||“-”如果遇到的加号或者减号（“ ”“-”优先级运算符里优先级最低），如果栈顶元素不是“(”(优先级为0)，并且栈不为空，则一直执行栈顶元素出栈，并压入结果栈中操作，当栈为空时或者遇到“(”，将“ ”“-”符号压入符号栈，继续往下遍历字符串。
4. Case：“*”||“/”||“%”如果遇到的是乘号、除号、取余运算（三个符号优先级相同，次高），如果栈顶元素是同级或者高级运算符（*  /  %  ^ 运算符）在栈不为空的情况下，不断对符号栈进行栈顶元素出符号栈、入结果栈的操作，直至不满足条件，退出循环为止。
5. Case：“^”在以上这些运算符中是相对最高级的，因此，只要遇到取幂运算，便将该符号压入符号栈中，接着遍历字符串。
6. 如果遇到的是空格，则不执行任何操作，直接进行下一个字符判断。

    等到程序遍历完字符串之后，首先进行一个简单的判断，查看符号栈中是否还有元素存在，若还有符号没有出栈，则该表达式一定是有误的，程序就会直接提示表达式有误，要求重新输入。当然，并不是栈为空，则该表达式就正确了，下面讲一下这个程序的报错机制。

2.3.3 报错机制

   首先，中缀转后缀的错误是相对没有那么容易发现的，因为只涉及到出栈、入栈等操作，即使你输入的表达式有误，如果程序到这里为止，依然能得到一个看似“正确”的结果。但是，像上面那个计算后缀表达式，是比较容易及时判断出错误的，所以，判断中缀表达式输入是否正确，我们先把这个中缀表达式转换成后缀表达式，若转化不成功，则该表达式必定有错，若转换成功，则对这个后缀表达式进行计算，如果能够得到正确结果，则说明这个中缀表达式是正确的，同时，输出result栈中的表达式；如果不行，则该表达式就是错误的，程序进行提示，并且要求重新输入中缀表达式，这就是这个程序的报错机制。如果没有错的话，在得到正确的后缀表达式的同时，我们还可以得到这个中缀表达式的计算结果。

下面是报错机制的流程图

3.功能实现

3.1 类 1

  采用表格的形式描述类的定义和功能

  类名称：MYstack

  功能： 作为辅助栈，存储后缀表达式的计算结果

1.  
   class Node {//定义一个节点，构造链表结构
2.  
   public:
3.  
   double data; Node *next;
4.  
   Node(double x1, Node *nex) :data(x1), next(nex) {
5.  
   }
6.  
   Node(double x1) :data(x1), next(0) {
7.  
   }
8.  
   };
9.  
    
10.  
     
11.  
    class Mystack {
12.  
     
13.  
    private:
14.  
    Node *first;
15.  
    int size;
16.  
    public:
17.  
    Mystack() :first(0), size(0) {//无参构造函数
18.  
    }
19.  
    Mystack(const Mystack&s);//拷贝构造函数
20.  
    ~Mystack();//析构函数
21.  
    int getsize();//返回栈中的数据个数
22.  
    void push(double x);//压入栈操作
23.  
    void pop();//删除栈顶元素
24.  
    void print();//打印结果
25.  
    Node* top();//提取栈顶元素
26.  
    friend void caculate(string str);//计算后缀表达式
27.  
    bool isempty();//判断栈是否为空
28.  
    friend bool calculatecopy(string str);//判断由中缀表达式转化而来的后缀表达式能否计算正确
29.  
    }

3.2 类 2 

  类名称：MYstack1

  功能： 作为辅助栈，存储运算符与转化的后缀表达式

1.  
   class Node1 {//定义节点，指向char类型数据
2.  
   public:
3.  
   char data; Node1 *next;
4.  
   Node1(char dat, Node1 *nex = 0) :data(dat), next(nex) {
5.  
   }
6.  
    
7.  
   };
8.  
    
9.  
   class Mystack1 {//类的定义
10.  
     
11.  
    private:
12.  
    Node1 *first;
13.  
    int size;
14.  
    public:
15.  
    Mystack1() :first(0), size(0) {//无参构造函数
16.  
    }
17.  
    Mystack1(const Mystack1&s);//拷贝构造函数
18.  
    ~Mystack1();//析构函数
19.  
     
20.  
    void push(char x);//将字符压入栈中
21.  
    void pop();//删除栈顶元素
22.  
    void print();//打印该表达式
23.  
    char top();//得到栈顶元素
24.  
    bool empty();//判断栈是否为空
25.  
    friend void exchange(string str);//将中缀表达式转化成后缀表达式
26.  
     
27.  
    };

4.功能截图

 4.1 中缀表达式转后缀运行截图

    1.只涉及个位数的转换

      下图为输出表达式（1 2）*5 6/3-7^1的计算过程，第一遍输出该表达式时，程序之所以报错是因为，该计算器仅仅支持半角输入的括号，如果输入了全角的括号，改程序不认识这个字符，就会告诉操作者在4这个位置输入了不合法字符。第一次输入时，因为输入的括号不是半角下的，程序无法识别，就会报错，提醒重新输入。重新输入后，进行表达式的计算，并且会输出一步步运行的过程。这其中，结果栈用来保存最后的结果，符号栈用来存储表达式中的符号，在程序经过判断后，在合适的时候出栈，并压入结果栈中。

下面输入一个中缀表达式进行程序功能的演示，输入的式子为（1 2）*5 6/3-7^1

如果自己转换一遍的的话结果为 1 2 5 * 6 3 / 7 1 ^ -

 

 因为每执行一步，就会有结果栈和符号栈的变化，所以输出的步骤会比较长。

 如图，我们已经得到了一个转换后的结果，但是，如果我们输入的表达式有误，并且那些潜在错误会避开判错程序，那个依然可以得到一个看似正确的结果。为了防止输入的表达式有错，对转换得到的后缀表达式进行计算，若能得到正确的计算结果，则输出该结果，并且将正确的后缀表达式输出。程序一边计算，一边显示出栈、入栈的具体过程

  2.浮点数及多位整数的转化

浮点数的中缀转后缀（主要是提取数字的过程多了一些），过程与上面类似。

下面的是浮点数有关的具体的转化过程。

 

 如果输入了不合法的字符，程序直接报错。

  3.可以转化出来，但是本身表达式就存在错误

  譬如说下面这个式子（1 2）*8 按照中缀转后缀的规则，的确是可以得到这样一个结果1 2 8 * ，但是我们自己判断一下，这个式子本身就是错误的，本身应该是无法转换的，因此，将转换后的式子拿去计算，我们发现得不出正确的结果，即可判断该式错误。

  

 同理，下面这个是除数为0程序也会进行提醒，不能转换

 

 4.2 计算后缀表达式功能运行截图

   1.输入一个合法的表达式

 

  浮点数不能进行取余运算，遇到这样的式子，程序会报错，例如下面这个式子，按常理的话，应该是这样计算的 1.27 7.3 7.3%2 但是7.3不是整数，无法进行取余运算，运行时，会报错。

 还有一种表达式有误，就是运算不够或者数字不够，运行的时候，如果是数字不够，则对栈进行判空的操作时，就会报出错误，如果是数字过多、运算符少，则最后的栈里面的值肯定不止一个，对栈的大小进行判断之后，会报出错误，就如下图所示。

 运算的时候，除数为0则直接报错。

5.问题和解决方法

5.1 多位数无法进行计算

5.2 浮点数无法计算 

5.3 无法准备判断表达式输入有误

 6.源代码

Mystack.h

1.  
   #pragma once
2.  
   #ifndef MYSTACK_H
3.  
   #define MYSTACK_H
4.  
   #include <iostream>
5.  
   #include <string>
6.  
   #include <sstream>
7.  
   #include <cmath>
8.  
   using namespace std;
9.  
    
10.  
    class Node {
11.  
    public:
12.  
    double data; Node *next;
13.  
    Node(double x1, Node *nex) :data(x1), next(nex) {
14.  
    }
15.  
    Node(double x1) :data(x1), next(0) {
16.  
    }
17.  
    };
18.  
     
19.  
     
20.  
    class Mystack {
21.  
     
22.  
    private:
23.  
    Node *first;
24.  
    int size;
25.  
    public:
26.  
    Mystack() :first(0), size(0) {
27.  
    }
28.  
    Mystack(const Mystack&s);
29.  
    ~Mystack();
30.  
    int getsize();
31.  
    void push(double x);
32.  
    void pop();
33.  
    void print();
34.  
    Node* top();
35.  
    friend void caculate(string str);
36.  
    bool isempty();
37.  
    friend bool calculatecopy(string str);
38.  
    };
39.  
    #endif

Mystack.cpp

1.  
   #include"Mystack.h"
2.  
   using namespace std;
3.  
   bool Mystack::isempty() {
4.  
   if (size == 0)return true;
5.  
   else return false;
6.  
    
7.  
   }
8.  
   int Mystack::getsize() {
9.  
   return size;
10.  
    }
11.  
    Mystack::Mystack(const Mystack&s) {
12.  
    Node *h, *q, *temp1;
13.  
    this->first = s.first;
14.  
    h = s.first;
15.  
     
16.  
    while (h)
17.  
    {
18.  
    if (first != 0) {
19.  
    h->next = first; first = h;
20.  
    }
21.  
    else { first = h; first->next = 0; }
22.  
     
23.  
     
24.  
    h = h->next;
25.  
    }
26.  
     
27.  
     
28.  
     
29.  
    }
30.  
    Node* Mystack::top() {
31.  
    return first;
32.  
    }
33.  
    void Mystack::push(double x) {
34.  
    Node *p = new Node(x);
35.  
     
36.  
    p->next = first; first = p;
37.  
    //入栈即在这个链表的最前面添加节点
38.  
    size ;
39.  
     
40.  
     
41.  
    }
42.  
    void Mystack::pop() {
43.  
    if (first) {//栈不为空
44.  
    Node *p = first;
45.  
    first = first->next;//删除栈的top值即删除链表的第一个节点
46.  
    size--;//数量--
47.  
    delete p;
48.  
     
49.  
    }
50.  
    else return;
51.  
    }
52.  
    Mystack::~Mystack() {
53.  
    Node*p1 = first;
54.  
    Node *p2 = p1;
55.  
    while (p1 != 0) {
56.  
    p2 = p1;
57.  
    p1 = p1->next;
58.  
    delete p2;
59.  
    }
60.  
    delete p1;
61.  
    }
62.  
    void Mystack::print() {
63.  
    Node*p1 = first;
64.  
    while (!p1) {
65.  
    cout << p1->data << " ";
66.  
    p1 = p1->next;
67.  
    }
68.  
    }

Mystack1.h

1.  
   #pragma once
2.  
   #ifndef MYSTACK1_H
3.  
   #define MYSTACK1_H
4.  
   #include<string>
5.  
   #include<iostream>
6.  
   #include <cstring>
7.  
   #include<sstream>
8.  
   #include<string.h>
9.  
   #include <cmath>
10.  
    using namespace std;
11.  
    class Node1 {
12.  
    public:
13.  
    char data; Node1 *next;
14.  
    Node1(char dat, Node1 *nex = 0) :data(dat), next(nex) {
15.  
    }
16.  
     
17.  
    };
18.  
     
19.  
    class Mystack1 {
20.  
     
21.  
    private:
22.  
    Node1 *first;
23.  
    int size;
24.  
    public:
25.  
    Mystack1() :first(0), size(0) {
26.  
    }
27.  
    Mystack1(const Mystack1&s);
28.  
    ~Mystack1();
29.  
     
30.  
    void push(char x);
31.  
    void pop();
32.  
    void print();
33.  
    char top();
34.  
    bool empty();
35.  
    friend void changeback(string str);
36.  
     
37.  
    };
38.  
    #endif

Mystack1.cpp

1.  
   #include"Mystack1.h"
2.  
   bool Mystack1::empty() {
3.  
   if (first == 0)return true;
4.  
   else return false;
5.  
   }
6.  
    
7.  
   Mystack1::Mystack1(const Mystack1&s) {
8.  
    
9.  
   Node1 *h;
10.  
    this->first = s.first;
11.  
    h = s.first;
12.  
     
13.  
    while (h)
14.  
    {
15.  
    if (first != 0) {
16.  
    h->next = first; first = h;
17.  
    }
18.  
    else { first = h; first->next = 0; }
19.  
     
20.  
     
21.  
    h = h->next;
22.  
    }
23.  
    }
24.  
     
25.  
    char Mystack1::top() {
26.  
    return first->data;
27.  
    }
28.  
     
29.  
    void Mystack1::push(char x) {
30.  
    Node1 *p = new Node1(x);
31.  
    if (first == 0) { first = p; first->next = 0; }
32.  
    else { p->next = first; first = p; }
33.  
    //入栈即在这个链表的最前面添加节点
34.  
     
35.  
    }
36.  
     
37.  
    void Mystack1::pop() {
38.  
    if (first) {//栈不为空
39.  
    Node1 *p = first;
40.  
    first = first->next;//删除栈的top值即删除链表的第一个节点
41.  
    size--;//数量--
42.  
    delete p;
43.  
     
44.  
    }
45.  
    else return;
46.  
    }
47.  
     
48.  
     
49.  
    Mystack1::~Mystack1() {
50.  
    Node1*p1 = first;
51.  
    Node1 *p2 = p1;
52.  
    while (p1 != 0) {
53.  
    p2 = p1;
54.  
    p1 = p1->next;
55.  
    delete p2;
56.  
    }
57.  
    delete p1;
58.  
    }
59.  
     
60.  
    void Mystack1::print() {
61.  
    Node1*p1 = first;
62.  
    char s1;
63.  
    string sum = "";
64.  
    while (p1 != 0) {
65.  
    s1 = p1->data;
66.  
    sum = s1 sum;
67.  
     
68.  
    p1 = p1->next;
69.  
     
70.  
    }
71.  
    cout << sum;
72.  
     
73.  
    }

主函数

1.  
   // 逆波兰.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
2.  
   //
3.  
   #include"Mystack1.h"
4.  
   #include"Mystack.h"
5.  
   #include <iostream>
6.  
   using namespace std;
7.  
   void caculate(string str) {
8.  
    
9.  
   Mystack s;
10.  
    int k = str.length();
11.  
    int i = 0;
12.  
    double x;
13.  
    int flag = 1;
14.  
    while (i < k&&flag == 1) {//遍历字符串
15.  
    if (str[i] == ' ' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '^' || str[i] == '%')//当前的是运算符，取栈顶两个元素进行相应的操作，将结果压入栈中
16.  
    {
17.  
    double num1, num2;
18.  
    switch (str[i])//判断该字符是运算符还是数字
19.  
    {
20.  
    case ' ':
21.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
22.  
    cout << "该表达式有误，无法计算" << endl;
23.  
    return;
24.  
    }
25.  
    num1 = s.top()->data;
26.  
    s.pop();
27.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
28.  
    cout << "该表达式有误，无法计算" << endl;
29.  
    return;
30.  
    }
31.  
    num2 = s.top()->data;
32.  
    s.pop();
33.  
    x = num1 num2;
34.  
     
35.  
     
36.  
    s.push(x);//把计算的结果压入栈中
37.  
    cout << "遇到加号 " << endl;//描述具体过程
38.  
    cout << num1 << " 和 " << num2 << "出栈进行加法运算 " << endl;
39.  
    cout << x << "入栈" << endl << endl;
40.  
    break;
41.  
    case '-':
42.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
43.  
    cout << "该表达式有误，无法计算" << endl;
44.  
    return;
45.  
    }
46.  
    num1 = s.top()->data;;
47.  
    s.pop();
48.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
49.  
    cout << "该表达式有误，无法计算" << endl;
50.  
    return;
51.  
    }
52.  
    num2 = s.top()->data;;
53.  
    s.pop();
54.  
    x = num2 - num1;
55.  
    s.push(x);
56.  
    cout << "遇到减号 - " << endl;
57.  
    cout << num1 << " 和 " << num2 << " 出栈进行减法运算 " << endl;
58.  
    cout << x << " 入栈 " << endl << endl;
59.  
    break;
60.  
    case '*':
61.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
62.  
    cout << "该表达式有误，无法计算" << endl;
63.  
    return;
64.  
    }
65.  
    num1 = s.top()->data;
66.  
    s.pop();
67.  
    if (s.isempty()) {
68.  
    cout << "该表达式有误，无法计算" << endl;
69.  
    return;
70.  
    }
71.  
    num2 = s.top()->data;
72.  
    s.pop();
73.  
    x = num1 * num2;
74.  
    s.push(x);
75.  
    cout << "遇到乘号 * " << endl;
76.  
    cout << num1 << " 和 " << num2 << " 出栈进行乘法运算 " << endl;
77.  
    cout << x << " 入栈" << endl << endl;
78.  
    break;
79.  
    case '/':
80.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
81.  
    cout << "该表达式有误，无法计算" << endl;
82.  
    return;
83.  
    }
84.  
    num1 = s.top()->data;
85.  
    s.pop();
86.  
    if (s.isempty() || num1 == 0) {//栈里面的元素不足，无法进行运算
87.  
    cout << "该表达式有误，无法计算" << endl;
88.  
    return;
89.  
    }
90.  
    num2 = s.top()->data;
91.  
    s.pop();
92.  
    x = num2 / num1;
93.  
    s.push(x);//将相除的运算的结果压入栈中
94.  
    cout << "遇到除号 / " << endl;
95.  
    cout << num1 << " 和 " << num2 << "出栈进行除法运算 " << endl;
96.  
    cout << x << " 入栈 " << endl << endl;
97.  
    break;
98.  
    case '^':
99.  
    if (s.isempty()) {//栈里面的元素不足，无法进行运算
100.  
     cout << "该表达式有误，无法计算" << endl;
101.  
     return;
102.  
     }
103.  
     num1 = s.top()->data;
104.  
     s.pop();
105.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
106.  
     cout << "该表达式有误，无法计算" << endl;
107.  
     return;
108.  
     }
109.  
     num2 = s.top()->data;
110.  
     s.pop();
111.  
     x = pow(num2, num1);
112.  
     s.push(x);//将取幂的结果压入栈中
113.  
     cout << "遇到指数符号 ^ " << endl;
114.  
     cout << num1 << " 和 " << num2 << "出栈进行取幂运算 " << endl;
115.  
     cout << x << " 入栈 " << endl << endl;
116.  
      
117.  
     break;
118.  
     case'%':
119.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
120.  
     cout << "该表达式有误，无法计算" << endl;
121.  
     return;
122.  
     }
123.  
     num1 = s.top()->data;
124.  
     s.pop();
125.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
126.  
     cout << "该表达式有误，无法计算" << endl;
127.  
     return;
128.  
     }
129.  
     num2 = s.top()->data;
130.  
     s.pop();
131.  
     int temp1 = (int)num1;
132.  
     int temp2 = (int)num2;
133.  
     if ((temp1 - num1) != 0 || (temp2 - num2) != 0) {//进行取余运算的两个数不是整数，不合逻辑
134.  
     cout << "浮点数无法进行取余运算 ！该表达式有误，无法计算" << endl;
135.  
     return;
136.  
      
137.  
     }
138.  
     x = temp2 % temp1;
139.  
     s.push(x);
140.  
     cout << "遇到取余符号 % " << endl;
141.  
     cout << num1 << " 和 " << num2 << "出栈进行取余运算 " << endl;
142.  
     cout << x << "入栈" << endl << endl;
143.  
      
144.  
     break;
145.  
     }
146.  
      
147.  
     }
148.  
     else if (str[i] == ' ') { i ; continue; }
149.  
     else if (str[i] >= '0'&&str[i] <= '9') {//遇到数字，开始数字提取
150.  
     double x = 0;
151.  
     double y = 0;
152.  
     while (((str[i] >= '0'&&str[i] <= '9') || str[i] == '.') && i < k) {//一直都是数字
153.  
      
154.  
     if (str[i] != '.') x = x * 10 int(str[i]) - 48;//没有遇到小数点，对整数部分进行提取
155.  
     else {//遇到小数点，对小数点后的数值进行相加
156.  
     i = i 1;
157.  
     while ((str[i] >= '0'&&str[i] <= '9') && i < k) {
158.  
     y ;//变量y相当于记录小数点后几位
159.  
     x = x (int(str[i]) - 48)*pow(10.0, -y);
160.  
     i ;
161.  
     }
162.  
      
163.  
     break;
164.  
     }
165.  
      
166.  
     i ;
167.  
     }
168.  
      
169.  
     s.push(x);//将提取出的数字压入栈中
170.  
     cout << x << "入栈" << endl << endl;
171.  
      
172.  
     continue;
173.  
      
174.  
     }
175.  
      
176.  
     i ;
177.  
      
178.  
     }
179.  
      
180.  
     if (s.getsize() != 1) {//最后栈的结果不唯一，或者为空
181.  
     cout << "该表达式有误，无法计算4" << endl;
182.  
      
183.  
     }
184.  
     else {//计算无误
185.  
      
186.  
     double y = s.top()->data;
187.  
     cout << str << endl;
188.  
     cout << "计算结果为 " << y << endl;//得出正确的结果
189.  
     }
190.  
     }
191.  
     bool calculatecopy(string str) {//判断由中缀转后缀的表达式能否进行计算，即判断该表达式的正确与否
192.  
     Mystack s;
193.  
     int k = str.length();
194.  
     int i = 0;
195.  
     double x;
196.  
     int flag = 1;
197.  
     while (i < k&&flag == 1) {//遍历字符串
198.  
     if (str[i] == ' ' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '^' || str[i] == '%')//当前的是运算符，取栈顶两个元素进行相应的操作，将结果压入栈中
199.  
     {
200.  
     double num1, num2;
201.  
     switch (str[i])
202.  
     {
203.  
     case ' ':
204.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
205.  
     cout << "该表达式有误，无法计算" << endl;
206.  
     return false;
207.  
     }
208.  
     num1 = s.top()->data;
209.  
     s.pop();
210.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
211.  
     cout << "该表达式有误，无法计算" << endl;
212.  
     return false;
213.  
     }
214.  
     num2 = s.top()->data;
215.  
     s.pop();
216.  
     x = num1 num2;
217.  
      
218.  
      
219.  
     s.push(x);
220.  
      
221.  
     break;
222.  
     case '-':
223.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
224.  
     cout << "该表达式有误，无法计算" << endl;
225.  
     return false ;
226.  
     }
227.  
     num1 = s.top()->data;;
228.  
     s.pop();
229.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
230.  
     cout << "该表达式有误，无法计算" << endl;
231.  
     return false ;
232.  
     }
233.  
     num2 = s.top()->data;;
234.  
     s.pop();
235.  
     x = num2 - num1;
236.  
     s.push(x);
237.  
      
238.  
     break;
239.  
     case '*':
240.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
241.  
     cout << "该表达式有误，无法计算" << endl;
242.  
     return false ;
243.  
     }
244.  
     num1 = s.top()->data;
245.  
     s.pop();
246.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
247.  
     cout << "该表达式有误，无法计算" << endl;
248.  
     return false ;
249.  
     }
250.  
     num2 = s.top()->data;
251.  
     s.pop();
252.  
     x = num1 * num2;
253.  
     s.push(x);
254.  
      
255.  
     break;
256.  
     case '/':
257.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
258.  
     cout << "该表达式有误，无法计算" << endl;
259.  
     return false ;
260.  
     }
261.  
     num1 = s.top()->data;
262.  
     s.pop();
263.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
264.  
     cout << "该表达式有误，无法计算" << endl;
265.  
     return false ;
266.  
     }
267.  
     num2 = s.top()->data;
268.  
     s.pop();
269.  
     x = num2 / num1;
270.  
     s.push(x);
271.  
      
272.  
     break;
273.  
     case '^':
274.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
275.  
     cout << "该表达式有误，无法计算" << endl;
276.  
     return false ;
277.  
     }
278.  
     num1 = s.top()->data;
279.  
     s.pop();
280.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
281.  
     cout << "该表达式有误，无法计算" << endl;
282.  
     return false ;
283.  
     }
284.  
     num2 = s.top()->data;
285.  
     s.pop();
286.  
     x = pow(num2, num1);
287.  
     s.push(x);
288.  
      
289.  
      
290.  
     break;
291.  
     case'%':
292.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
293.  
     cout << "该表达式有误，无法计算" << endl;
294.  
     return false ;
295.  
     }
296.  
     num1 = s.top()->data;
297.  
     s.pop();
298.  
     if (s.isempty()) {//栈里面的元素不足，无法进行运算
299.  
     cout << "该表达式有误，无法计算" << endl;
300.  
     return false;
301.  
     }
302.  
     num2 = s.top()->data;
303.  
     s.pop();
304.  
     int temp1 = (int)num1;
305.  
     int temp2 = (int)num2;
306.  
     if ((temp1 - num1) != 0 || (temp2 - num2) != 0) {
307.  
     cout << "浮点数无法进行取余运算 ！该表达式有误，无法计算" << endl;
308.  
     flag = 0;
309.  
     return false;
310.  
      
311.  
     }
312.  
     x = temp2 % temp1;
313.  
     s.push(x);
314.  
      
315.  
     break;
316.  
     }
317.  
      
318.  
     }
319.  
     else if (str[i] == ' ') { i ; continue; }
320.  
     else if (str[i] >= '0'&&str[i] <= '9') {//提取数字，和上面是一样的操作
321.  
     double x = 0;
322.  
     double y = 0;
323.  
     while (((str[i] >= '0'&&str[i] <= '9') || str[i] == '.') && i < k) {
324.  
      
325.  
     if (str[i] != '.') x = x * 10 int(str[i]) - 48;
326.  
     else {
327.  
     i = i 1;
328.  
     while ((str[i] >= '0'&&str[i] <= '9') && i < k) {
329.  
     y ;
330.  
     x = x (int(str[i]) - 48)*pow(10.0, -y);
331.  
     i ;
332.  
     }
333.  
      
334.  
     break;
335.  
     }
336.  
      
337.  
     i ;
338.  
     }
339.  
      
340.  
     s.push(x);
341.  
      
342.  
      
343.  
     continue;
344.  
      
345.  
     }
346.  
      
347.  
     i ;
348.  
      
349.  
     }
350.  
      
351.  
     if (s.getsize() != 1) {
352.  
     cout << "该表达式有误，无法计算" << endl;
353.  
     return false;
354.  
      
355.  
     }
356.  
     else {
357.  
      
358.  
     double y = s.top()->data;
359.  
     cout << str << endl;
360.  
     cout << "该中缀表达式计算结果为 " << y << endl;//可以得到一个正确的计算的结果，即该表示正确
361.  
     return true;
362.  
     }
363.  
      
364.  
      
365.  
     }
366.  
     void changeback(string str) {//中缀转后缀表达式
367.  
     Mystack1 stk;
368.  
     Mystack1 result;
369.  
      
370.  
     char temp;
371.  
     for (int i = 0; i < str.length(); i ) {//一个个提取字符
372.  
     int flag = 0;
373.  
     while (str[i] >= '0'&&str[i] <= '9') {//提取数字
374.  
      
375.  
     result.push(str[i]); flag = 1;
376.  
     cout << str[i] << " 入结果栈 ";
377.  
     i ;
378.  
     if (str[i] == '.') {
379.  
     result.push(str[i]);
380.  
     cout << str[i] << " 入结果栈 ";
381.  
     i ;
382.  
     }
383.  
      
384.  
     }
385.  
     if (flag == 1) {
386.  
     i--;
387.  
     result.push(' ');//用空格将表达式分开，避免无法区分数字
388.  
     }
389.  
      
390.  
     if (str[i] == ' ' || str[i] == '-') {//遇到加号、减号两个运算符较低的
391.  
     while (1) {
392.  
     if (!stk.empty() && stk.top() != '(') {//如果栈不为空，或者不是最低级的左括号运算符则将栈顶元素弹出
393.  
     temp = stk.top();
394.  
     cout << temp << " 入结果栈 ";
395.  
     cout << temp << " 出符号栈 ";
396.  
     result.push(temp);
397.  
     result.push(' ');
398.  
     stk.pop();
399.  
     }
400.  
     else {//栈为空或者遇到左括号（运算级别最低的运算符）
401.  
     cout << str[i] << " 入符号栈 ";
402.  
     stk.push(str[i]);
403.  
     break;
404.  
     }
405.  
     }
406.  
     }
407.  
      
408.  
     else if (str[i] == '*' || str[i] == '/' || str[i] == '%') {//* / %这三个运算符运算级别相同
409.  
     while (1) {//遇到是同级或者更高级的运算符
410.  
     //将原本栈中的元素弹出，压到结果栈中
411.  
     if (!stk.empty() && (stk.top() == '*' || stk.top() == '/' || stk.top() == '%' || stk.top() == '^')) {
412.  
     temp = stk.top();
413.  
     cout << temp << " 入结果栈 ";
414.  
     cout << temp << " 出符号栈 ";
415.  
     result.push(temp);
416.  
     result.push(' ');
417.  
     stk.pop();
418.  
     }
419.  
      
420.  
     else {//遇到的是低级的运算符
421.  
     cout << str[i] << " 入符号栈 ";
422.  
     stk.push(str[i]);
423.  
     break;
424.  
     }
425.  
     }
426.  
     }
427.  
     else if (str[i] == '^') {//遇到了最高级的运算符，直接压入符号栈中
428.  
     cout << str[i] << " 入符号栈 ";
429.  
     stk.push(str[i]);
430.  
      
431.  
     }
432.  
     else if (str[i] == '(') {
433.  
     stk.push(str[i]);
434.  
     cout << str[i] << " 入符号栈 ";
435.  
     }
436.  
     else if (str[i] == ')') {//遇到右括号，除非遇到左括号，持续弹出符号栈栈顶元素
437.  
     while (1) {
438.  
     while(stk.top() != '(') {
439.  
     temp = stk.top();
440.  
     cout << temp << " 入结果栈 ";
441.  
     cout << temp << " 出符号栈 ";
442.  
     result.push(temp);
443.  
     result.push(' ');
444.  
     stk.pop();
445.  
     }
446.  
     stk.pop(); //删除'('
447.  
     break;
448.  
     }
449.  
      
450.  
     }
451.  
      
452.  
     cout << endl;
453.  
     cout << "执行这一步后 " ;
454.  
     cout << "结果栈为" << " "; result.print();
455.  
     cout << "符号栈为" << " "; stk.print();
456.  
     cout << endl << endl;
457.  
     }
458.  
     while (!stk.empty()) {//符号栈不为空，将所有符号弹出
459.  
     temp = stk.top();
460.  
     cout << temp << " 入结果栈 ";
461.  
     cout << temp << " 出符号栈 ";
462.  
     result.push(temp);
463.  
     result.push(' ');
464.  
     stk.pop();
465.  
     cout << endl;
466.  
     cout << "执行这一步后 ";
467.  
     cout << "结果栈为" << " "; result.print();
468.  
     cout << "符号栈为" << " "; stk.print();
469.  
     cout << endl << endl;
470.  
      
471.  
     }
472.  
      
473.  
     Node1*p1 = result.first;
474.  
     char s1;
475.  
     string sum = "";
476.  
     while (p1 != 0) {
477.  
     s1 = p1->data;
478.  
     sum = s1 sum;
479.  
      
480.  
     p1 = p1->next;
481.  
      
482.  
     }//得到该后缀表达式，因为无法确定该式是否正确，下面对其进行计算判断
483.  
     if (calculatecopy(sum) == true) {
484.  
     cout << endl;
485.  
     cout << str;
486.  
     cout << endl << "最终的后缀表达式为" << endl;
487.  
     cout << sum;
488.  
      
489.  
     cout << endl;
490.  
     }
491.  
     else {
492.  
      
493.  
     cout << "该式通过计算不能得到正确结果" << endl;
494.  
     cout << "请输入一个正确的表达式";
495.  
     }
496.  
     }
497.  
      
498.  
     int main()
499.  
     {
500.  
      
501.  
     int dd = 1;
502.  
     int s;
503.  
     int k;
504.  
     int chance;
505.  
     cout << endl;
506.  
     cout << endl;
507.  
     cout << endl;
508.  
     cout << " ==============================================="<<endl;
509.  
     cout << " || 请输入你想要进行的操作 ||" << endl;
510.  
     cout << " || 按 1 进入中缀转后缀表达式 ||" << endl;
511.  
     cout << " || 按 2 进入后缀表达式的计算 ||" << endl;
512.  
     cout << " || 按 3 退出该系统 ||"<<endl;
513.  
     cout << " ===============================================";
514.  
     cout << endl;
515.  
     while (cin >> chance) {
516.  
      
517.  
      
518.  
      
519.  
     if (chance == 1) {
520.  
     string str;
521.  
     system("cls");//
522.  
      
523.  
     cout << endl << endl << endl;
524.  
     cout << " ==================欢迎进入中缀转后缀功能区==================="<<endl;
525.  
     cout << " =============================================================" << endl;
526.  
     cout << " =============================================================" << endl;
527.  
     cout << "请输入中缀表达式（注意括号仅仅支持半角输入） ";
528.  
     cout << "按#退出输入" << endl;
529.  
     while (getline(cin, str) && str != "#") {//
530.  
      
531.  
     if (str == "")continue;
532.  
     int flag = 1;
533.  
      
534.  
     for (int i = 0; i < str.length(); i ) {//
535.  
     int a = str[i];
536.  
      
537.  
     if (!((a >= 45 && a <= 57) || a == 42 || a == 43 || a == 37
538.  
     || a == 32 || a == 40 || a == 41||a==94))//
539.  
      
540.  
     {
541.  
     flag = 0;
542.  
      
543.  
     cout << i << " " << str[i] << " ";
544.  
     cout << "该表达式输入了无法解析的字符 表达式有误 请重新输入" << endl;
545.  
     cout << "若要退出该功能请按#" << endl;
546.  
     break;
547.  
     }
548.  
      
549.  
     }
550.  
     if (flag == 0)continue;
551.  
     changeback(str);//
552.  
     cout << "==============================================================================";
553.  
     cout << endl<<endl<<endl;
554.  
     cout << "请输入中缀表达式（注意括号仅仅支持半角输入） ";
555.  
     cout << "按#退出输入" << endl;
556.  
      
557.  
     }
558.  
      
559.  
     }
560.  
     else if (chance == 2) {//
561.  
     system("cls");
562.  
     cout << endl << endl << endl;
563.  
     cout << " =============计算后缀表达式功能区============= " << endl;
564.  
     cout << " ==============================================" << endl;
565.  
     cout << " ==============================================" << endl;
566.  
     cout << "输入要计算的表达式，#键退出计算器：" << endl;
567.  
     string str1;
568.  
      
569.  
     while (getline(cin, str1)&&str1!="#")
570.  
     {
571.  
     if (str1 == "")continue;
572.  
     if (str1 == " ")continue;
573.  
     int flag = 1;
574.  
     if (str1 == "#")
575.  
     break;
576.  
     for (int i = 0; i < str1.length(); i ) {
577.  
     int a = str1[i];
578.  
      
579.  
     if (!((a >= 45 && a <= 57) || a == 42 || a == 43 || a == 37 || a == 32 || a == 94))//根据运算符的ASC码来判断是否有不合法的
580.  
      
581.  
     {
582.  
      
583.  
     flag = 0;
584.  
     cout << " 在 " << i << " 这个位置 " << str1[i] << " ";
585.  
     cout << "该表达式输入了无法解析的字符 表达式有误 请重新输入" << endl;
586.  
     cout << "若要退出该功能请按#"<<endl;
587.  
      
588.  
     break;
589.  
     }
590.  
     }
591.  
      
592.  
     if (flag != 1)continue;
593.  
     caculate(str1);//
594.  
     cout << "==============================================================================";
595.  
     cout << endl << endl << endl;
596.  
     cout << "输入要计算的表达式，#键退出计算器：" << endl;
597.  
      
598.  
     }
599.  
      
600.  
      
601.  
     }
602.  
     else if(chance==3) {
603.  
     return 0;
604.  
     }
605.  
     else {
606.  
      
607.  
     cout << "请输入你要进行的操作" << endl; continue;
608.  
     }
609.  
     dd ;
610.  
     system("cls");
611.  
     cout << endl;
612.  
     cout << endl;
613.  
     cout << endl;
614.  
     cout << " ===============================================" << endl;
615.  
     cout << " || 请输入你想要进行的操作 ||" << endl;
616.  
     cout << " || 按 1 进入中缀转后缀表达式 ||" << endl;
617.  
     cout << " || 按 2 进入后缀表达式的计算 ||" << endl;
618.  
     cout << " || 按 3 退出该系统 ||" << endl;
619.  
     cout << " ===============================================";
620.  
     cout << endl;
621.  
      
622.  
      
623.  
     }
624.  
      
625.  
     }
626.  
      

这篇好文章是转载于：学新通技术网