递归输出去括号的中缀表达式
1. 定义一棵简化的 Linked Binary Tree
1.1. Binary Tree Node
假设元素类型为 std::string,
include 如下几个头文件.
#include <iostream>
#include <string>
先定义 Node.
元素类型为 std::string
struct binaryTreeNode
{
std::string element;
binaryTreeNode* leftChild, * rightChild;
// Constructor 1.
binaryTreeNode() { leftChild = rightChild = nullptr; }
// Constructor 2.
binaryTreeNode(const std::string& theElement) :
element(theElement), leftChild(nullptr), rightChild(nullptr) {}
// Constructor 3.
binaryTreeNode(const std::string& theElement, binaryTreeNode* theLeft, binaryTreeNode* theRight) :
element(theElement), leftChild(theLeft), rightChild(theRight) {}
};
1.2. Linked Binary Tree
再利用 binaryTreeNode 写一个简单的 linked binary tree.
这里初始化树的方法是用户输入以空格划分的树的前序遍历结果, 同时指出何处为 nullptr.
e.g.
假设指定了 "#" 表示 nullptr, 即将"#"传入形参 stop.
用户输入:+ * 1 # # - 2 # # 3 # # / 4 # # 5 # #;
所表示的表达式应为: 1*(2-3)+4/5 ;
其中 "+" 为树的 root.
class linkedBinaryTree
{
public:
// Constructor, initialize {root} with nullptr.
linkedBinaryTree() : root(nullptr) {};
// Get private member {root}.
binaryTreeNode* getRoot() const { return root; }
// Initialize the tree with pre-order-output string of an expression;
// {stop} indicates nullptr.
void createTree(binaryTreeNode* root, const std::string& stop)
{
std::string element;
std::cin >> element;
if (element == stop) { return; }
root = new binaryTreeNode(element);
createTree(root->leftChild, stop);
createTree(root->rightChild, stop);
}
private:
binaryTreeNode* root;
};
2. 输出去括号的中缀表达式
2.1. 两个辅助函数
判断元素是否为运算符.
inline bool isOperator(const std::string& op)
{
if (op == "+" || op == "-" || op == "*" || op == "/") { return true; }
return false;
}
返回运算符优先级.
运算符优先级按照这种特殊的方式设定值,
是考虑到将返回值 除以 2 后能形成一层新的 加减 与 乘除 的划分
inline int getOperPri(const std::string& op)
{
switch (op[0]) {
case '+': return 2;
case '-': return 3;
case '*': return 4;
case '/': return 5;
default: return -1;
}
}
2.2. 递归输出中缀表达式同时去括号
为了去括号, 递归的时候还要传入一个 prePri, 表示上层的优先级.
顺手枚举个 direction 类型, 表示本层递归是前一层走哪个方向进来的.
具体实现并不复杂, 注释得比较清晰了.
关于加减遇到负数的变号, 实现起来也比较轻松, 大致方法写在注释里了.
enum direction { start = -1, left, right };
void infix(binaryTreeNode* t, int prePri, direction dir)
{
if (t == nullptr) { return; }
int curPri = 0; // Mark current operator priority (0 if element is a number).
bool flag = true; // <true> to print brakets; <false> not to.
if (isOperator(t->element)) { // IF current element is an operator.
curPri = getOperPri(t->element); // Get current priority.
if (dir == left) {
if (curPri / 2 >= prePri / 2) { flag = false; }
} else if (dir == right) {
if (curPri > prePri || curPri == prePri && !(prePri & 1)) { flag = false; }
} else { // IF {dir} is start, do not print brakets.
flag = false;
}
} else { // IF element is a number.
// IF the number is possitive, does not need brackets.
if (std::stoi(t->element) > 0) { flag = false; }
// If you wish, you can also add some codes here to change '+' and '-' operator when meeting a negative number.
// e.g. When the current element is <-3>, and {prePri} indicates that the operator before is '+';
// Send a signal back to last level with return value in order to change '+' to '-'.
}
if (flag) { std::cout << '('; }
// Recurse to left subtree.
infix(t->leftChild, curPri, left);
// Print element.
std::cout << t->element;
// Recurse to right subtree.
infix(t->rightChild, curPri, right);
if (flag) { std::cout << ')'; }
}
3. 方法使用示例
在 有 2.2. 中定义的枚举类型 direction 的情况下,
函数 void infix(binaryTreeNode* t, int prePri, direction dir) 的第四个参数必须是 direction 的变量 start (表示递归第一层);
第三个参数 prePri 在 start 的限制下, 调用函数是可以传入任意值 (因为 prePri 在递归的第一层不会参与比较).
int main()
{
std::string stop;
std::cin >> stop; // User define {stop} to indicate nullptr.
linkedBinaryTree tree; // Define an empty tree.
tree.createTree(tree.getRoot(), stop); // Create the tree.
// Output the result.
// The 4th parameter must be <start>, while the 3rd does not matter.
infix(tree.getRoot(), 0, start);
system("pause");
}
4. 后记
潇潇给我的这题还挺有意思的.
深知目前自己的能力还非常不足. 哈哈.
不过 <欢迎来到实力至上主义的教室> 小说真的好看呢.
一之濑真好呀, 和天使一样!
第二季动画做的... 呃呃... 感觉不太好.
04/08/2022 17:37
