4 remake

#include <iostream>
#include <queue>
#include <string>
#include <stack>
using namespace std;
class TreeNode {
public:
    char value;  // символьное значение узла
    TreeNode* left;  // указатель на левое поддерево
    TreeNode* right;  // указатель на правое поддерево

    TreeNode(char v) : value(v), left(nullptr), right(nullptr) {}
};

class ExpressionTree {
private:
    TreeNode* root;

    TreeNode* parseExpression(const string& expr, int start, int end) {
        if (start > end) {
            return nullptr;
        }

        // Поиск операции с наименьшим приоритетом
        for (int i = end; i >= start; i--) {
            if (expr[i] == '+' || expr[i] == '-') {
                TreeNode* node = new TreeNode(expr[i]);
                node->left = parseExpression(expr, start, i - 1);
                node->right = parseExpression(expr, i + 1, end);
                return node;
            }
        }

        // Поиск операции с более высоким приоритетом
        for (int i = end; i >= start; i--) {
            if (expr[i] == '*' || expr[i] == '/') {
                TreeNode* node = new TreeNode(expr[i]);
                node->left = parseExpression(expr, start, i - 1);
                node->right = parseExpression(expr, i + 1, end);
                return node;
            }
        }

        // Если операция не найдена, это число
        return new TreeNode(expr[start]);
    }

public:
    ExpressionTree() : root(nullptr) {}

    void buildFromExpression(const string& expr) {
        root = parseExpression(expr, 0, expr.length() - 1);
    }

    void display() {
        displayTree(root);
    }

    void simplify() {
        root = simplifyTree(root);
    }

    void breadthFirstDisplay() {
        breadthFirstTraversal(root);
        cout << endl;
    }

    void displayTree(TreeNode* node, int level = 0) {
        if (!node) {
            return;
        }

        displayTree(node->right, level + 1);
        for (int i = 0; i < level; i++) {
            cout << "    ";
        }
        cout << node->value << endl;
        displayTree(node->left, level + 1);
    }

    TreeNode* simplifyTree(TreeNode* node) {
        if (!node) {
            return nullptr;
        }

        node->left = simplifyTree(node->left);
        node->right = simplifyTree(node->right);

        if (node->value == '+') {
            if (node->left && node->left->value == '0') {
                TreeNode* temp = node->right;
                delete node;
                return temp;
            }
            if (node->right && node->right->value == '0') {
                TreeNode* temp = node->left;
                delete node;
                return temp;
            }
        }
        else if (node->value == '-') {
            if (node->right && node->right->value == '0') {
                TreeNode* temp = node->left;
                delete node;
                return temp;
            }
        }
        else if (node->value == '*') {
            if (node->left && node->left->value == '1') {
                TreeNode* temp = node->right;
                delete node;
                return temp;
            }
            if (node->right && node->right->value == '1') {
                TreeNode* temp = node->left;
                delete node;
                return temp;
            }
            if ((node->left && node->left->value == '0') || (node->right && node->right->value == '0')) {
                delete node;
                return new TreeNode('0');
            }
        }

        return node;
    }

    void breadthFirstTraversal(TreeNode* node) {
        if (!node) {
            return;
        }

        queue<TreeNode*> q;
        q.push(node);

        while (!q.empty()) {
            TreeNode* current = q.front();
            q.pop();

            cout << current->value << " ";

            if (current->left) {
                q.push(current->left);
            }
            if (current->right) {
                q.push(current->right);
            }
        }
    }
};

int main() {
    setlocale(LC_ALL, "Russian");

    cout << "Тест 1: Создание дерева из выражения '5'" << endl;
    ExpressionTree tree1;
    tree1.buildFromExpression("5");
    tree1.display();
    cout << "---------------\n";

    cout << "Тест 2: Упрощение дерева выражения '1+0'" << endl;
    ExpressionTree tree2;
    tree2.buildFromExpression("1+0");
    cout << "Дерево до упрощения:" << endl;
    tree2.display();
    cout << "---------------\n";

    tree2.simplify();

    cout << "Дерево после упрощения:" << endl;
    tree2.display();
    cout << "---------------\n";

    cout << "Тест 3: Обход дерева в ширину для выражения '1+2*3'" << endl;
    ExpressionTree tree3;
    tree3.buildFromExpression("1+2*3");
    tree3.breadthFirstDisplay();
    cout << "---------------\n";

    cout << "Тест 4: Упрощение сложного дерева для выражения '1+2*3-0'" << endl;
    ExpressionTree tree4;
    tree4.buildFromExpression("1+2*3-0");

    cout << "Дерево до упрощения:" << endl;
    tree4.display();
    cout << "---------------\n";

    tree4.simplify();

    cout << "Дерево после упрощения:" << endl;
    tree4.display();
    cout << "---------------\n";

    cout << "Тест 5: Создание и упрощение дерева с выражением '6/2*3+1-0'" << endl;
    ExpressionTree tree5;
    tree5.buildFromExpression("6/2*3+1-0");

    cout << "Дерево до упрощения:" << endl;
    tree5.display();
    cout << "---------------\n";

    tree5.simplify();

    cout << "Дерево после упрощения:" << endl;
    tree5.display();
    cout << "---------------\n";

    return 0;
}