(21/05) Crear pila simple

[GitMory]

include iostream>

using namespace std;

class Nodo { public: int dato; Nodo* siguiente; };

class Pila { private: Nodo* top;

public: Pila() { top = nullptr; }

void push(int valor) {
    Nodo* nuevo = new Nodo();
    nuevo->dato = valor;
    nuevo->siguiente = top;
    top = nuevo;
}

void pop() {
    if (top != nullptr) {
        Nodo* temp = top;
        top = top->siguiente;
        delete temp;
    } else {
        cout << "La pila está vacía." << endl;
    }
}

void mostrar() {
    Nodo* temp = top;
    cout<<"---------------------------------------"<< endl;
    while (temp != nullptr) {
        cout << temp->dato << " ";
        temp = temp->siguiente;
    }
    cout<<"\n---------------------------------------"<< endl;
}

void salir() {
    cout << "Saliendo del programa..." << endl;
}

};

int main() { Pila pila; int opcion, valor;

do {
    cout << "\t1. Ingresar elemento a la pila" << endl;
    cout << "\t2. Eliminar elemento de la pila" << endl;
    cout << "\t3. Mostrar pila" << endl;
    cout << "\t4. Salir" << endl;
    cout << "Ingrese una opción: ";
    cin >> opcion;

    switch (opcion) {
        case 1:
            cout << "Ingrese el valor a ingresar: ";
            cin >> valor;
            pila.push(valor);
            break;
        case 2:
            pila.pop();
            break;
        case 3:
            cout << "Contenido de la pila: " << endl;
            pila.mostrar();
            break;
        case 4:
            pila.salir();
            break;
        default:
            cout << "Opción inválida. Inténtelo de nuevo." << endl;
    }
} while (opcion != 4);

return 0;

}

[GitMory]

include iostream>

include nostring>

// Definición del nodo de la pila struct Nodo { char dato; Nodo* siguiente; };

// Clase Pila class Pila { private: Nodo* cima;

public: Pila() : cima(nullptr) {}

~Pila() {
    while (!isEmpty()) {
        pop();
    }
}

void push(char valor) {
    Nodo* nuevoNodo = new Nodo();
    nuevoNodo->dato = valor;
    nuevoNodo->siguiente = cima;
    cima = nuevoNodo;
}

void pop() {
    if (isEmpty()) {
        std::cerr << "La pila está vacía, no se puede hacer pop.\n";
        return;
    }
    Nodo* temp = cima;
    cima = cima->siguiente;
    delete temp;
}

char top() {
    if (isEmpty()) {
        std::cerr << "La pila está vacía, no hay elemento en la cima.\n";
        return '\0'; // Carácter nulo para indicar que la pila está vacía
    }
    return cima->dato;
}

bool isEmpty() {
    return cima == nullptr;
}

};

// Función para verificar si los paréntesis, llaves y corchetes están balanceados bool estanBalanceados(const std::string& expresion) { Pila pila;

for (char ch : expresion) {
    if (ch == '(' || ch == '{' || ch == '[') {
        pila.push(ch);
    } else if (ch == ')' || ch == '}' || ch == ']') {
        if (pila.isEmpty()) {
            return false;
        }
        char cima = pila.top();
        pila.pop();
        if ((ch == ')' && cima != '(') || 
            (ch == '}' && cima != '{') || 
            (ch == ']' && cima != '[')) {
            return false;
        }
    }
}
return pila.isEmpty();

}

int main() { std::string expresion1 = "(A+B - [2 3] - C)"; std::string expresion2 = "(A+B - [2 3) - C]"; std::string expresion3 = "{ ( A + B - [ 2 * 3 }";

std::cout << "Expresion 1: " << (estanBalanceados(expresion1) ? "Balanceado" : "No está balanceado") << std::endl;
std::cout << "Expresion 2: " << (estanBalanceados(expresion2) ? "Balanceado" : "No está balanceado") << std::endl;
std::cout << "Expresion 3: " << (estanBalanceados(expresion3) ? "Balanceado" : "No está balanceado") << std::endl;

return 0;

}

[GitMory]

include iostream>

include string>

using namespace std;

struct Nodo { char dato; Nodo* siguiente; };

class Pila { private: Nodo* cima; public: Pila() : cima(nullptr) {}

~Pila() {
    while (!esVacia()) {
        pop();
    }
}

void push(char valor) {
    Nodo* nuevoNodo = new Nodo();
    nuevoNodo->dato = valor;
    nuevoNodo->siguiente = cima;
    cima = nuevoNodo;
}

void pop() {
    if (esVacia()) {
        return;
    }
    Nodo* temp = cima;
    cima = cima->siguiente;
    delete temp;
}

char tope() {
    if (esVacia()) {
        return '\0'; // Retorna un caracter nulo si la pila está vacía
    }
    return cima->dato;
}

bool esVacia() {
    return cima == nullptr;
}

};

bool estanBalanceados(const std::string& expresion) { Pila pila; for (char c : expresion) { if (c == '(' || c == '{' || c == '[') { pila.push(c); } else if (c == ')' || c == '}' || c == ']') { if (pila.esVacia()) { return false; // Hay un paréntesis de cierre sin correspondencia } char tope = pila.tope(); if ((c == ')' && tope == '(') || (c == '}' && tope == '{') || (c == ']' && tope == '[')) { pila.pop(); } else { return false; // No coincide el paréntesis de cierre con el de apertura } } } return pila.esVacia(); }

string verificarBalanceo(const string& expresion) { if (estanBalanceados(expresion)) { return "BALANCEADO CORRECTAMENTE"; } else { for (char c : expresion) { if (c == ')' || c == '}' || c == ']') { if (estanBalanceados(expresion)) { return "BALANCEADO INCORRECTAMENTE"; } else { return "NO ESTÁN BALANCEADOS"; } } } return "NO ESTÁN BALANCEADOS"; } }

int main() { string expresion; cout << "Ingrese una expresion aritmetica: "; getline(cin, expresion);

string resultado = verificarBalanceo(expresion);
cout << resultado << endl;

return 0;

}