Algoritmia - Parseo de cadena con parentesis

#include <iostream>

#include <string>

#include <stack>

// Estructura para representar una expresión booleana

struct Query {

    char operador;  // Operador: 'a' (AND), 'o' (OR), 'n' (NOT), 'v' (valor)

    bool valor;     // Valor (true o false)

    Query* izquierda;   // Subexpresión izquierda

    Query* derecha;     // Subexpresión derecha

    // Constructor para crear un objeto Query

    Query(char op, bool val, Query* izq = nullptr, Query* der = nullptr)

        : operador(op), valor(val), izquierda(izq), derecha(der) {}

};

// Función para crear un objeto Query a partir de una cadena de entrada

Query* generarQuery(const std::string& expresion) {

    std::stack<Query*> pila;

    for (char c : expresion) {

        if (c == ' ') {

            continue;

        } else if (c == 'a' || c == 'o' || c == 'n') {

            Query* q = new Query(c, false);

            pila.push(q);

        } else if (c == '[') {

            // No hacemos nada

        } else if (c == ']') {

            Query* derecha = pila.top();

            pila.pop();

            Query* operador = pila.top();

            pila.pop();

            Query* izquierda = pila.top();

            pila.pop();

            operador->izquierda = izquierda;

            operador->derecha = derecha;

            pila.push(operador);

        } else if (c == 'v') {

            Query* q = new Query(c, true);

            pila.push(q);

        }

    }

    return pila.top();

}

// Función para evaluar un objeto Query

bool evaluarQuery(Query* query) {

    if (query->operador == 'v') {

        return query->valor;

    } else if (query->operador == 'a') {

        return evaluarQuery(query->izquierda) && evaluarQuery(query->derecha);

    } else if (query->operador == 'o') {

        return evaluarQuery(query->izquierda) || evaluarQuery(query->derecha);

    } else if (query->operador == 'n') {

        return !evaluarQuery(query->izquierda);

    }

    return false; // Nunca debería llegar aquí

}

int main() {

    std::string expresion = "[a] and [b] or [c] diferente a [a] and [[b] or [c]]";

    Query* query = generarQuery(expresion);

    std::cout << "Resultado de la expresión: " << std::boolalpha << evaluarQuery(query) << std::endl;

    // Liberar la memoria

    // Esta parte del código se debe ajustar según la estructura real del objeto Query

    delete query->derecha->izquierda;

    delete query->derecha->derecha;

    delete query->derecha;

    delete query->izquierda;

    delete query;

    return 0;

}