Está en la página 1de 10

Ejercicios propuestos – Pilas

1. Multiplique los elementos de una pila por un valor. Solo


debe utilizar funciones de pilas (push y pop). Los void recorerPila(Nodo* lista)
elementos de la pila resultante deberán estar en el {
orden original. Nodo* p = lista;
while (p!=NULL)
#include <iostream> {
cout<<p->info<<endl;
using namespace std; p = p->sgte;
}
struct Nodo }
{
int info; int main()
Nodo* sgte; {
}; Nodo* lista = NULL;
ingresarDatos(lista);
void push (Nodo* &lista, int x) cout<<"-----PILA ORIGINAL-----\n";
{ recorerPila(lista);
Nodo* nuevo = new Nodo; multiplicarDatos(lista);
nuevo->info = x; cout<<"-----PILA MULTIPLICADA-----\n";
nuevo->sgte = lista; recorerPila(lista);
lista = nuevo; return 0;
} }

int pop(Nodo* &lista) 2. Se tiene un archivo de modo texto, se pide mostrar


{ cada línea empezando por la ultima.
Nodo* temp = lista;
int n; #include <iostream>
n = lista->info; #include <fstream>
lista = lista->sgte;
delete temp; using namespace std;
return n;
} struct Nodo
{
void ingresarDatos(Nodo* &lista) string info;
{ Nodo* sgte;
int n, x; };
cout<<"Ingrese cantidad de datos: ";
cin>>n; void push (Nodo* &lista, string x)
for (int i=0; i<n; i++) {
{ Nodo* nuevo = new Nodo;
cout<<"Ingrese dato "<<i+1<<": "; nuevo->info = x;
cin>>x; nuevo->sgte = lista;
push(lista, x); lista = nuevo;
} }
}
string pop(Nodo* &lista)
void multiplicarDatos(Nodo* &lista) {
{ string x;
Nodo* listaTemp = NULL; Nodo* temp = lista;
int num, m; x = lista->info;
cout<<"Ingrese numero multiplicador: "; lista = lista->sgte;
cin>>m; delete temp;
while (lista!=NULL) return x;
{ }
num = pop(lista) * m;
push(listaTemp,num); void popearLista (Nodo* &lista)
} {
while (listaTemp!=NULL) string x;
{ while (lista!=NULL)
num = pop(listaTemp); {
push(lista, num); x = pop(lista);
} cout<<x<<endl;
delete listaTemp; }
} }

1
if (exp[i]== '}')
int main() {
{ if (l1!=NULL)
Nodo* lista = NULL; {
string x; pop(l1);
ifstream abrirArchivo("texto.txt",ios::in); }
while (getline(abrirArchivo,x)) else
{ {
push(lista, x); ll = ll+1;
} }
popearLista(lista); }
return 0; }
} if (exp[i] == '(')
{
3. Lea un archivo que contenga un programa en C/C++ y push(l2, exp[i]);
determine si los símbolos {}, () y [] están correctamente }
balanceados. Si no lo están muestre el error indicando else
el símbolo faltante. {
if (exp[i]== ')')
#include <iostream> {
#include <string.h> if (l2!=NULL)
{
using namespace std; pop(l2);
}
struct Nodo else
{ {
char info; par = par+1;
Nodo* sgte; }
}; }
}
void push (Nodo* &lista, char x) if (exp[i] == '[')
{ {
Nodo* nuevo = new Nodo; push(l3, exp[i]);
nuevo->info = x; }
nuevo->sgte = lista; else
lista = nuevo; {
} if (exp[i]== ']')
{
char pop (Nodo* &lista) if (l3!=NULL)
{ {
char x; pop(l3);
Nodo* temp = lista; }
x = lista->info; else
lista = lista->sgte; {
delete temp; cor = cor+1;
return x; }
} }
}
void leerExpresion (char expresion[30], int &l) }
{ if (l1==NULL && l2==NULL && l3==NULL && ll==0
cout<<"Ingrese expresion: "; && par==0 && cor==0)
cin.getline(expresion,30); {
l = strlen(expresion); cout<<"La expresion esta correctamente
} balanceada.";
}
void evaluarSymbols (Nodo* &l1, Nodo* &l2, Nodo* else
&l3, char exp[30], int l) {
{ if (l1!=NULL || ll>0)
int ll=0, par=0, cor=0; {
for (int i=0; i<l; i++) cout<<"Falta(n) llave(s)."<<endl;
{ }
if (exp[i] == '{') if (l2!=NULL || par>0)
{ {
push(l1, exp[i]); cout<<"Falta(n) parentesis."<<endl;
} }
else if (l3!=NULL || cor>0)
{ {

2
cout<<"Falta(n) corchete(s)."<<endl; while (p!=NULL && dividir==false)
} {
} if (x == p->sgte->info)
} {
dividir = true;
int main() lista2 = p->sgte;
{ p->sgte = NULL;
Nodo* l1 = NULL; //Pila para las {} }
Nodo* l2 = NULL; // Pila para los () }
Nodo* l3 = NULL; // Pila para los [] }
char expresion[30];
int lon; void mostrarPila (Nodo* &lista)
leerExpresion(expresion, lon); {
evaluarSymbols(l1, l2, l3, expresion, lon); int x;
return 0; while(lista!=NULL)
} {
x = pop(lista);
4. Divida una pila en 2 a partir de un valor determinado. cout<<x<<endl;
}
#include <iostream> }

using namespace std; int main()


{
struct Nodo Nodo* lista = NULL;
{ Nodo* lista2 = NULL;
int info; ingresarDatos(lista);
Nodo* sgte; dividirPila(lista,lista2);
}; cout<<"----PILA 1----\n";
mostrarPila(lista);
void push (Nodo* &lista, int x) cout<<"----PILA 2----\n";
{ mostrarPila(lista2);
Nodo* nuevo = new Nodo; return 0;
nuevo->info = x; }
nuevo->sgte = lista;
lista = nuevo; 5. Un disc jockey selecciona de una lista un conjunto de
} canciones, luego coloca los CDS uno encima de otro
según el orden que serán tocados, una vez tocados los
int pop (Nodo* &lista) coloca uno encima del otro conforme los toca, al final
{ de su turno los vuelve a colocar en el estante de cd.
int x; Haga un programa para esta situación.
Nodo* temp = lista;
x = lista->info; #include <iostream>
lista = lista->sgte;
delete temp; using namespace std;
return x;
} struct Nodo
{
void ingresarDatos(Nodo* &lista) int info;
{ Nodo* ante;
int n, x; Nodo* sgte;
cout<<"Ingrese cantidad de datos: "; };
cin>>n;
for (int i=0; i<n; i++) void addAlFinal (Nodo* &primero, Nodo* &ultimo, int x)
{ {
cout<<"Ingrese dato "<<i+1<<": "; Nodo* nuevo = new Nodo;
cin>>x; Nodo* p = primero;
push(lista, x); nuevo->info = x;
} nuevo->sgte = NULL;
} ultimo = nuevo;
if (primero==NULL)
void dividirPila(Nodo* lista, Nodo* &lista2) {
{ primero = nuevo;
bool dividir = false; nuevo->ante = NULL;
Nodo* p = lista; }
int x; else
cout<<"Ingrese dato en el iniciara la division: "; {
cin>>x; while(p->sgte!=NULL)

3
{ {
p = p->sgte; push(pilaPorTocar,x);
}
nuevo->ante = p; if (p->ante==NULL && p->sgte==NULL)
p->sgte = nuevo; {
} primero = NULL;
} ultimo = NULL;
}
void push (Nodo* &lista, int x) else
{ {
Nodo* nuevo = new Nodo; if (p->ante == NULL)
nuevo->info = x; {
nuevo->sgte = lista; primero = p->sgte;
lista = nuevo; p->sgte->ante = p->ante;
} }
else
int pop (Nodo* &lista) {
{ if (p->sgte == NULL)
int x; {
Nodo* temp = lista; ultimo = p->ante;
x = lista->info; p->ante->sgte = NULL;
lista = lista->sgte; }
delete temp; else
return x; {
} p->ante->sgte = p->sgte;
p->sgte->ante = p->ante;
void ingresarDatos (Nodo* &primero, Nodo* &ultimo) }
{ }
int n; }
cout<<"Ingrese cantidad de CD's: "; }
cin>>n; p = p->sgte;
for (int i=0; i<n; i++) }
{ }
addAlFinal(primero,ultimo,i+1); }
}
} void cdsTocados (Nodo* &pilaPorTocar, Nodo*
&pilaTocados)
void mostrarDatos (Nodo* lista) {
{ int x;
Nodo* p = lista; while (pilaPorTocar!=NULL)
if (p==NULL) {
{ x = pop(pilaPorTocar);
cout<<"No hay CDs\n"; push(pilaTocados,x);
} }
while (p!=NULL) }
{
cout<<"CD "<<p->info<<endl; void regresarCDs(Nodo* &primero, Nodo* &ultimo,
p = p->sgte; Nodo* &pilaTocados)
} {
} int x;
Nodo* p = primero;
void cdsATocar (Nodo* &primero, Nodo* &ultimo, while (pilaTocados!=NULL)
Nodo* &pilaPorTocar) {
{ x = pop(pilaTocados);
int n, x; addAlFinal(primero,ultimo,x);
Nodo* p; }
Nodo* temp; }
cout<<"Ingrese cantidad de CDs a elegir: ";
cin>>n; int main()
for (int i=0; i<n; i++) {
{ Nodo* primero = NULL;
cout<<"Ingrese nro de CD elegido: "; Nodo* ultimo = NULL;
cin>>x; Nodo* pilaPorTocar = NULL;
p = primero; Nodo* pilaTocados = NULL;
while (p!=NULL) ingresarDatos(primero,ultimo);
{ cout<<"----ESTANTE DE CD'S----\n";
if (p->info == x) mostrarDatos(primero);

4
cdsATocar(primero,ultimo,pilaPorTocar); for (int i=0; i<n; i++)
cout<<"========== DESPUES DE ELEGIR {
========\n"; cout<<"Ingrese dato "<<i+1<<": ";
cout<<"---ESTANTE DE CD'S---\n"; cin>>x;
mostrarDatos(primero); push(lista, x);
cout<<"---PILA DE CD'S POR TOCAR---\n"; }
mostrarDatos(pilaPorTocar); }
cout<<"---PILA DE CD'S TOCADOS---\n";
mostrarDatos(pilaTocados); void reemplazarElemento(Nodo* lista)
cout<<"========== DESPUES DE TOCAR {
=========\n"; int rd, nd, x;
cdsTocados(pilaPorTocar,pilaTocados); Nodo* temp = NULL;
cout<<"---ESTANTE DE CD'S---\n"; cout<<"Ingrese dato a reemplazar: ";
mostrarDatos(primero); cin>>rd;
cout<<"---PILA DE CD'S POR TOCAR---\n"; cout<<"Ingrese nuevo dato: ";
mostrarDatos(pilaPorTocar); cin>>nd;
cout<<"---PILA DE CD'S TOCADOS---\n"; while (lista->info!=rd)
mostrarDatos(pilaTocados); {
cout<<"==== SE REGRESAN LOS CDs AL x = pop(lista);
ESTANTE====\n"; push(temp,x);
regresarCDs(primero,ultimo,pilaTocados); }
cout<<"---ESTANTE DE CD'S---\n"; lista->info = nd;
mostrarDatos(primero); while (temp!=NULL)
cout<<"---PILA DE CD'S POR TOCAR---\n"; {
mostrarDatos(pilaPorTocar); x = pop(temp);
cout<<"---PILA DE CD'S TOCADOS---\n"; push(lista, x);
mostrarDatos(pilaTocados); }
return 0; delete temp;
} }

6. Reemplace un elemento de una pila por otro. void mostrarDatos (Nodo* lista)
Recuerde que acceder a un elemento de la pila elimina {
su elemento. Sugerencia: use una pila auxiliar. Nodo* p = lista;
if (p==NULL)
#include <iostream> {
cout<<"No hay datos\n";
using namespace std; }
while (p!=NULL)
struct Nodo {
{ cout<<p->info<<endl;
int info; p = p->sgte;
Nodo* sgte; }
}; }

void push(Nodo* &lista, int x) int main()


{ {
Nodo* nuevo = new Nodo; Nodo* lista = NULL;
nuevo->info = x; ingresarDatos(lista);
nuevo->sgte = lista; cout<<"--Pila Inicial--\n";
lista = nuevo; mostrarDatos(lista);
} reemplazarElemento(lista);
cout<<"--Nueva Pila--\n";
int pop (Nodo* &lista) mostrarDatos(lista);
{ return 0;
int x; }
Nodo* temp = lista;
x = lista->info; 7. Ingrese un número al revés y luego pruebe su memoria
lista = lista->sgte; ingresándolo nuevamente, pero con sus cifras
delete temp; invertidas. Usando pilas, diga cuantos errores cometió
return x; al ingresar el número invertido. Por ejemplo, si el
} número fue 12345 y usted ingreso 54221, entonces
cometió un error.
void ingresarDatos(Nodo* &lista)
{ #include <iostream>
int n, x;
cout<<"Ingrese cantidad de datos: "; using namespace std;
cin>>n;

5
struct Nodo n = n/10;
{ }
int info; else
Nodo* sgte; {
}; c = c+1;
noError = noError*false;
void push(Nodo* &lista, int x) cout<<"Usted ha fallado.\n";
{ }
Nodo* nuevo = new Nodo; push(temp,x);
nuevo->info = x; }
nuevo->sgte = lista; if (noError == true)
lista = nuevo; {
} cout<<"Usted ha ingresado el numero
correcto.\n";
int pop (Nodo* &lista) cout<<"Cometio "<<c<<" errores.";
{ correcto = true;
int x; }
Nodo* temp = lista; while(temp!=NULL)
x = lista->info; {
lista = lista->sgte; x = pop(temp);
delete temp; push(lista,x);
return x; }
} mostrarDatos(lista);
}
void ingresarNumero(Nodo* &lista) }
{
int n; int main()
cout<<"Ingrese numero: "; {
cin>>n; Nodo* lista = NULL;
while (n>0) ingresarNumero(lista);
{ mostrarDatos(lista);
push(lista,n%10); compararNumero(lista);
n = n/10; return 0;
} }
}
8. Determine si dos pilas son iguales. Recuerde que
void mostrarDatos (Nodo* lista) acceder a un elemento de la pila elimina su elemento.
{ Sugerencia: use pilas auxiliares
Nodo* p = lista;
if (p==NULL) #include <iostream>
{
cout<<"No hay datos\n"; using namespace std;
}
while (p!=NULL) struct Nodo
{ {
cout<<p->info<<endl; int info;
p = p->sgte; Nodo* sgte;
} };
}
void push (Nodo* &lista, int x)
void compararNumero (Nodo* &lista) {
{ Nodo* nuevo = new Nodo;
bool correcto = false; nuevo->info = x;
bool noError; nuevo->sgte = lista;
int n, x, c = 0; lista = nuevo;
Nodo* temp; }
while (correcto == false)
{ int pop (Nodo* &lista)
temp = NULL; {
noError = true; int x;
cout<<"Ingrese numero al revez: "; Nodo* temp = lista;
cin>>n; x = lista->info;
while (lista!=NULL && noError==true) lista = lista->sgte;
{ delete temp;
x = pop(lista); return x;
if (n%10 == x) }
{

6
void ingresarDatos (Nodo* &lista, int n) #include <iostream>
{
int x; using namespace std;
for (int i=0; i<n; i++)
{ struct Nodo
cout<<"Ingrese dato "<<i+1<<": "; {
cin>>x; int info;
push(lista,x); Nodo* sgte;
} };
}
void push (Nodo* &lista, int x)
void compararDatos (Nodo* &lista1, Nodo* &lista2) {
{ Nodo* nuevo = new Nodo;
int x1, x2; nuevo->info = x;
bool igualdad = true; nuevo->sgte = lista;
Nodo* temp1 = NULL; lista = nuevo;
Nodo* temp2 = NULL; }
while (lista1!=NULL && lista2!=NULL &&
igualdad==true) int pop (Nodo* &lista)
{ {
x1 = pop(lista1); int x;
x2 = pop(lista2); Nodo* temp = lista;
if (x1 != x2) x = lista->info;
{ lista = lista->sgte;
igualdad = false; delete temp;
} return x;
push(temp1,x1); }
push(temp2,x2);
} void ingresarDatos (Nodo* &lista)
while (temp1!=NULL && temp2!=NULL) {
{ int n, x;
x1 = pop(temp1); cout<<"Ingrese cantidad de datos: ";
x2 = pop(temp2); cin>>n;
push(lista1,x1); for (int i=0; i<n; i++)
push(lista2,x2); {
} cout<<"Ingrese dato "<<i+1<<": ";
if (igualdad == true) cin>>x;
{ push(lista, x);
cout<<"Ambas pilas son iguales."; }
} }
else
{ void calcularNElementos(Nodo* &lista)
cout<<"Las pilas son diferentes."; {
} int x, c = 0;
Nodo* temp = NULL;
} while (lista!=NULL)
{
x = pop(lista);
int main() push(temp, x);
{ c = c+1;
int n; }
Nodo* lista1 = NULL; cout<<"El numero de elementos es: "<<c;
Nodo* lista2 = NULL; while (temp!=NULL)
cout<<"Ingrese cantidad de datos: "; {
cin>>n; x = pop(temp);
cout<<"---Pila 1---\n"; push(lista, x);
ingresarDatos(lista1, n); }
cout<<"---Pila 2---\n"; delete temp;
ingresarDatos(lista2, n); }
compararDatos(lista1,lista2);
return 0; int main()
} {
Nodo* lista = NULL;
9. Calcular el número de elementos de una pila sin ingresarDatos(lista);
modificar su contenido. Recuerde que acceder a un calcularNElementos(lista);
elemento de la pila elimina su elemento. Sugerencia: return 0;
use dos pilas. }

7
}
10. Elimine un elemento de una Pila. Use pilas auxiliares. while (temp!=NULL)
{
#include <iostream> x = pop(temp);
push(lista, x);
using namespace std; }
if (encontrado == false)
struct Nodo {
{ cout<<"No se encontro el dato a eliminar.\n";
int info; }
Nodo* sgte; else
}; {
cout<<"Se elimino el dato.\n";
void push (Nodo* &lista, int x) }
{ }
Nodo* nuevo = new Nodo;
nuevo->info = x; void recorerPila (Nodo* lista)
nuevo->sgte = lista; {
lista = nuevo; Nodo* p = lista;
} while (p!=NULL)
{
int pop (Nodo* &lista) cout<<p->info<<endl;
{ p = p->sgte;
int x; }
Nodo* temp = lista; }
x = lista->info;
lista = lista->sgte; int main()
delete temp; {
return x; Nodo* lista = NULL;
} ingresarDatos(lista);
eliminarDato(lista);
void ingresarDatos (Nodo* &lista) recorerPila(lista);
{ return 0;
int n, x; }
cout<<"Ingrese cantidad de datos: ";
cin>>n; 11. Realizar un procedimiento que ingrese un elemento en
for (int i=0; i<n; i++) la posición N de una pila. Tener en cuenta que los
{ demás elementos deben quedar en el mismo orden.
cout<<"Ingrese dato "<<i+1<<": ";
cin>>x; #include <iostream>
push(lista, x);
} using namespace std;
}
struct Nodo
void eliminarDato (Nodo* &lista) {
{ int info;
int e, x; Nodo* sgte;
Nodo* temp = NULL; };
bool encontrado = false;
cout<<"Ingrese dato a eliminar: "; void push (Nodo* &lista, int x)
cin>>e; {
while (lista!=NULL && encontrado==false) Nodo* nuevo = new Nodo;
{ nuevo->info = x;
x = pop(lista); nuevo->sgte = lista;
if (x==e) lista = nuevo;
{ }
encontrado = true;
while (temp!=NULL) int pop (Nodo* &lista)
{ {
x = pop(temp); int x;
push(lista, x); Nodo* temp = lista;
} x = lista->info;
} lista = lista->sgte;
else delete temp;
{ return x;
push(temp,x); }
}

8
void ingresarDatos (Nodo* &lista) Nodo* sgte;
{ };
int n, x;
cout<<"Ingrese cantidad de datos: "; void push (Nodo* &lista, int x)
cin>>n; {
for (int i=0; i<n; i++) Nodo* nuevo = new Nodo;
{ nuevo->info = x;
cout<<"Ingrese dato "<<i+1<<": "; nuevo->sgte = lista;
cin>>x; lista = nuevo;
push(lista, x); }
}
} int pop (Nodo* &lista)
{
void agregarDato(Nodo* &lista) int x;
{ Nodo* temp = lista;
Nodo* temp = NULL; x = lista->info;
int x, n, a; lista = lista->sgte;
int i=0; delete temp;
cout<<"Ingrese nuevo dato: "; return x;
cin>>x; }
cout<<"Ingrese posicion del nuevo dato: ";
cin>>n; void ingresarDatos (Nodo* &lista, char x[50])
while (i<n-1 && lista!=NULL) {
{ int i=0;
a = pop(lista); cout<<"Ingrese cadena de caracteres: ";
push(temp, a); cin.getline(x, 50);
i = i+1; while (x[i]!='\0')
} {
push(lista, x); push(lista,x[i]);
while (temp!=NULL) i = i+1;
{ }
a = pop(temp); }
push(lista, a);
} void voltearCadena (Nodo* &lista, char y[50])
} {
char x;
void recorrerPila (Nodo* lista) int i = 0;
{ while (lista!=NULL)
Nodo* p = lista; {
while (p!=NULL) x = pop(lista);
{ y[i] = x;
cout<<p->info<<endl; i = i+1;
p = p->sgte; }
} y[i] = '\0';
} }

int main() int main()


{ {
Nodo* lista = NULL; char x[50];
ingresarDatos(lista); char y[50];
cout<<"---PILA INGRESADA---\n"; Nodo* lista = NULL;
recorrerPila(lista); ingresarDatos(lista, x);
agregarDato(lista); cout<<"\nCadena 1: "<<x;
cout<<"---PILA MODIFICADA---\n"; voltearCadena(lista, y);
recorrerPila(lista); cout<<"\nCadena volteada: "<<y;
return 0; return 0;
} }

12. Usando una pila invierta una cadena.


13. Leer una frase y luego invierta el orden de las palabras
#include <iostream> en la frase. Por Ejemplo: “una imagen vale por mil
palabras” debe convertirse en “palabras mil por vale
using namespace std; imagen una”.

struct Nodo #include <iostream>


{ #include <string.h>
char info; #include <cstdlib>

9
#include <vector> void recorerPila (Nodo* lista)
{
using namespace std; string x;
while (lista!=NULL)
struct Nodo {
{ x = pop(lista);
string info; cout<<x<<" ";
Nodo* sgte; }
}; }

void push (Nodo* &lista, string x) int main()


{ {
Nodo* nuevo = new Nodo; Nodo* lista = NULL;
nuevo->info = x; ingresarDatos(lista);
nuevo->sgte = lista; recorerPila(lista);
lista = nuevo; return 0;
} }

string pop(Nodo* &lista) 14. Simular la operación de n pilas operando


{ simultáneamente y donde se saca y/o inserta
string x; elementos al azar a cualquiera de las pilas. Determine
Nodo* temp = lista; cuál es la pila de mayor trabajo y cual es la pila de
x = lista->info; menos trabajo en un tiempo determinado de
lista = lista->sgte; operación.
delete temp;
return x;
} 15. Se tienen dos pilas (stacks) que contienen números
enteros; la primera ordenada ascendentemente desde
vector<string> spliter(string &str, int &c, char el tope hacia el fondo, y la segunda ordenada
separador) descendentemente desde el tope hacia el fondo.
{ Elabore un programa que fusione ambas pilas en una
vector<string> resultado; tercera ordenada descendentemente desde el tope
size_t pos1 = 0; hacia el fondo. NOTA: no debe utilizar pilas auxiliares.
size_t pos2 = 0;
while (pos2 != str.npos)
{
pos2 = str.find(separador, pos1);
if (pos2 != str.npos)
{
if (pos2 > pos1)
{
resultado.push_back(str.substr(pos1,pos2-
pos1));
}
pos1 = pos2+1;
}
c = c+1;
}
resultado.push_back(str.substr(pos1, str.size()-
pos1));
return resultado;
}

void ingresarDatos(Nodo* &lista)


{
string x;
vector<string> palabras;
int i = 0, c = 0;
cout<<"Ingrese cadena de palabras: ";
getline(cin,x);
palabras = spliter(x,c,' ');
for (i=0; i<c; i++)
{
push(lista, palabras[i]);
}
}

10