PrefixExpression/ExprStruct.h at main · OrisGo/PrefixExpression · GitHub

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
#pragma once

#ifndef EXPRSTRUCT_H
#define EXPRSTRUCT_H


#include <qstring.h>
#include <cmath>
#include <unordered_map>
#include <QDebug>

inline bool isOperator(char c)
{
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
}


double calculate(char P, double val1, double val2);

struct Node
{
    /*
     * 二叉树结点
     * 若为叶子结点，操作树为 0~9 或 变量
     */

    double val = 0;

    bool isOperand;
    bool existVar;
    char c;
    Node* left = nullptr;
    Node* right = nullptr;


    Node(char P, bool isOperator = true);

    Node(const Node& other) = delete;

    // ~Node();
    // {
    //     // delete left;
    //     // delete right;
    // }
};


inline void destroy(Node* root)
{
    if(!root) return;

    destroy(root->left);
    destroy(root->right);

    delete root;
}


class Expr{
public:
    bool existVar = false;
    Node* root = nullptr;
    QString prefix;
    std::unordered_map<char,double> varMap;
public:
    Expr() = default;

    Expr(const Expr& other);

    Expr& operator=(const Expr& other);


    ~Expr();

    QString toInfix() const;

    QString toTree() const;

    void setVarValue(char c,double v);

    double value();

private:
    QString toInfix(Node* root) const;

    void generateTreeString(Node* root, QString pre, bool isTail, QString &str) const;
    double calculate(Node* root);

public:
    Node* clone(const Node* other);

};


bool validPrefix(QString s);


Expr createExpr(QString prefix);


Expr compoundExpr(char P, const Expr& e1,const Expr& e2);


#endif // EXPRSTRUCT_H