Ejercicios propuestos – Listas enlazadas dobles y circulares

1. Escriba un programa que permita recorrer una {

lista doble en ambos sentidos. cout<<p->info<<endl;
p = p->ante;
#include <iostream> }
}
using namespace std;
int main()
struct NodoD {
{ NodoD* primero = NULL;
int info; NodoD* ultimo = NULL;
NodoD* ante; ingresarDatos(primero, ultimo);
NodoD* sgte; mostrarDeIzqDer(primero);
}; mostrarDeDerIzq(ultimo);
return 0;
void addAlFinal (NodoD* &primero, NodoD* &ultimo, }
int x)
{
NodoD* nuevo = new NodoD; 2. Ingresar 2 listas doblemente enlazadas y reportar:
nuevo->info = x; a) Si las listas son iguales en tamaño y
nuevo->sgte = NULL; contenido
if (primero==NULL) b) Si las listas son iguales en tamaño pero no
{ en contenido
nuevo->ante = NULL; c) No tienen el mismo tamaño ni contenido.
primero = nuevo;
ultimo = nuevo; #include <iostream>
}
else using namespace std;
{
nuevo->ante = ultimo; struct NodoD
ultimo->sgte = nuevo; {
ultimo = nuevo; int info;
} NodoD* ante;
} NodoD* sgte;
};
void ingresarDatos(NodoD* &primero, NodoD*
&ultimo) void addAlFinal(NodoD* &primero, NodoD* &ultimo,
{ int x)
int n, x; {
cout<<"Ingrese cantidad de datos: "; NodoD* nuevo = new NodoD;
cin>>n; nuevo->info = x;
for (int i=0; i<n; i++) nuevo->sgte = NULL;
{ if (primero==NULL)
cout<<"Ingrese dato "<<i+1<<": "; {
cin>>x; nuevo->ante = NULL;
addAlFinal(primero, ultimo, x); primero = nuevo;
} ultimo = nuevo;
} }
else
void mostrarDeIzqDer(NodoD* primero) {
{ nuevo->ante = ultimo;
cout<<"-----Lista de Izq a Der-----\n"; ultimo->sgte = nuevo;
NodoD* p = primero; ultimo = nuevo;
while(p!=NULL) }
{ }
cout<<p->info<<endl;
p = p->sgte; void ingresarDatos (NodoD* &primero, NodoD*
} &ultimo, int a)
} {
int n, x;
void mostrarDeDerIzq(NodoD* ultimo) cout<<"-------LISTA "<<a<<"--------\n";
{ cout<<"Ingrese cantidad de datos: ";
cout<<"-----Lista de Der a Izq-----\n"; cin>>n;
NodoD* p = ultimo; for (int i=0; i<n; i++)
while(p!=NULL) {

1
 cout<<"Ingrese dato "<<i+1<<": "; cout<<"Las listas son iguales en tamaño pero
cin>>x; no en contenido.";
addAlFinal(primero, ultimo, x); }
} }
} else
{
void mostrarDatos(NodoD* primero, int a) cout<<"No tienen el mismo tamaño ni
{ contenido.";
NodoD* p = primero; }
cout<<"-------LISTA "<<a<<"--------\n"; }
while(p!=NULL)
{ int main()
cout<<p->info<<endl; {
p = p->sgte; NodoD* primero1 = NULL;
} NodoD* ultimo1 = NULL;
} NodoD* primero2 = NULL;
NodoD* ultimo2 = NULL;
bool compararContenido(NodoD* p1, NodoD* p2) ingresarDatos(primero1, ultimo1,1);
{ ingresarDatos(primero2, ultimo2,2);
bool igualdad; mostrarDatos(primero1,1);
bool igualdadF = true; mostrarDatos(primero2,2);
NodoD* p = p1; reportar(primero1, primero2);
NodoD* q; return 0;
while(p!=NULL) }
{
q = p2; 3. Escribir un programa que permita invertir los
igualdad = false; datos almacenados en una lista doblemente
while(q!=NULL && igualdad==false) enlazada, es decir que el primer elemento pase a
{ ser el último y el último pase a ser el primero, que
if (p->info == q->info) el segundo sea el penúltimo y el penúltimo pase a
{ ser el segundo y así sucesivamente.
igualdad = true;
} #include <iostream>
q = q->sgte;
} using namespace std;
igualdadF = igualdadF * igualdad;
p = p->sgte; struct NodoD
} {
return igualdadF; int info;
} NodoD* ante;
NodoD* sgte;
int contar(NodoD* p) };
{
int c=0; void addAlFinal(NodoD* &primero, NodoD* &ultimo,
while (p!=NULL) int x)
{ {
p = p->sgte; NodoD* nuevo = new NodoD;
c = c+1; nuevo->info = x;
} nuevo->sgte = NULL;
return c; if (primero==NULL)
} {
nuevo->ante = NULL;
void reportar (NodoD* p1, NodoD* p2) primero = nuevo;
{ ultimo = nuevo;
int c1, c2; }
c1 = contar(p1); else
c2 = contar(p2); {
if (c1 == c2) nuevo->ante = ultimo;
{ ultimo->sgte = nuevo;
if (compararContenido(p1,p2)==true) ultimo = nuevo;
{ }
cout<<"Las listas son iguales en tamaño y }
contenido.";
} void ingresarDatos(NodoD* &primero, NodoD*
else &ultimo)
{ {
int n, x;

2
 cout<<"Ingrese cantidad de datos: "; NodoD* ante;
cin>>n; NodoD* sgte;
for(int i=0; i<n; i++) };
{
cout<<"Ingrese dato "<<i+1<<": "; void addAlFinal (NodoD* &primero, NodoD* &ultimo,
cin>>x; int x)
addAlFinal(primero, ultimo, x); {
} NodoD* nuevo = new NodoD;
} nuevo->info = x;
nuevo->sgte = NULL;
void mostrarDatos(NodoD* primero) if (primero==NULL)
{ {
NodoD* p = primero; nuevo->ante = NULL;
while(p!=NULL) primero = nuevo;
{ ultimo = nuevo;
cout<<p->info<<endl; }
p = p->sgte; else
} {
} ultimo->sgte = nuevo;
nuevo->ante = ultimo;
void voltearRecursivo(NodoD* &p) ultimo = nuevo;
{ }
NodoD* temp; }
temp = p->sgte;
p->sgte = p->ante; void ingresarDatos(NodoD* &primero, NodoD*
p->ante = temp; &ultimo)
if (p->sgte!=NULL) {
{ int n, x;
voltearRecursivo(p->sgte); cout<<"Ingrese cantidad de datos: ";
} cin>>n;
} for (int i=0; i<n; i++)
{
void voltearDatos(NodoD* &primero, NodoD* cout<<"Ingrese dato "<<i+1<<": ";
&ultimo) cin>>x;
{ addAlFinal(primero, ultimo, x);
NodoD* temp; }
temp = primero; }
primero = ultimo;
ultimo = temp; void buscarDato(NodoD* primero)
voltearRecursivo(primero); {
} int x, c = 0;
NodoD* p = primero;
int main() cout<<"Ingrese dato a buscar: ";
{ cin>>x;
NodoD* primero = NULL; while (p!=NULL)
NodoD* ultimo = NULL; {
ingresarDatos(primero,ultimo); if (x == p->info)
mostrarDatos(primero); {
voltearDatos(primero, ultimo); c = c + 1;
mostrarDatos(primero); }
return 0; p = p->sgte;
} }
if (c>0)
4. Escribir un programa que retorne el número de {
veces que se encuentra el dato dentro de la lista cout<<"El dato ("<<x<<") se encontro: "<<c<<"
doble. En caso de no encontrarse, se debe veces.";
mostrar un mensaje indicando que el dato no fue }
encontrado. Se debe ingresar el valor que se else
desea buscar. {
cout<<"El dato no fue encontrado.";
#include <iostream> }
}
using namespace std;
int main()
struct NodoD {
{ NodoD* primero = NULL;
int info; NodoD* ultimo = NULL;

3
 ingresarDatos(primero, ultimo); cout<<p->info<<endl;
buscarDato(primero); }
return 0; p = p->sgte;
} c = c+1;
}
5. Crear una lista doblemente enlazada con 50 }
números enteros, del 1 al 999 generados
aleatoriamente. Una vez creada la lista, se deben void delimitarRango (int minV, int maxV, NodoD*
eliminar los nodos que estén fuera de un rango de &primero, NodoD* &ultimo)
valores leídos desde el teclado. {
NodoD* p = primero;
#include <iostream> while (p!=NULL)
#include <cstdlib> {
#include <ctime> if (p->info<minV || p->info>maxV)
{
using namespace std; if (p->ante==NULL)
{
struct NodoD primero = p->sgte;
{ p->sgte->ante = NULL;
int info; }
NodoD* ante; else
NodoD* sgte; {
}; if (p->sgte==NULL)
{
void addAlFinal(NodoD* &primero, NodoD* &ultimo, ultimo = p->ante;
int x) p->ante->sgte = NULL;
{ }
NodoD* nuevo = new NodoD; else
nuevo->info = x; {
nuevo->sgte = NULL; p->ante->sgte = p->sgte;
if (primero==NULL) p->sgte->ante = p->ante;
{ }
nuevo->ante = NULL; }
primero = nuevo; }
ultimo = nuevo; p = p->sgte;
} }
else }
{
ultimo->sgte = nuevo; void addRango(NodoD* &primero, NodoD* &ultimo)
nuevo->ante = ultimo; {
ultimo = nuevo; int minV, maxV;
} cout<<"Ingrese valor minimo: ";
} cin>>minV;
cout<<"Ingrese valor máximo: ";
void crearLista (NodoD* &primero, NodoD* &ultimo) cin>>maxV;
{ delimitarRango(minV, maxV, primero, ultimo);
int x; }
for (int i=0; i<50; i++)
{ int main()
x = rand()%999 + 1; {
addAlFinal(primero, ultimo, x); srand((unsigned)time(NULL));
} NodoD* primero = NULL;
} NodoD* ultimo = NULL;
crearLista(primero, ultimo);
void mostrarDatos (NodoD* primero) mostrarDatos(primero);
{ addRango(primero, ultimo);
int c = 1; mostrarDatos(primero);
NodoD* p = primero; return 0;
cout<<"-------Datos creados------\n"; }
while (p!=NULL)
{ 6. Crear un programa que maneje el registro de los
if (c%5!=0 || c==1) estudiantes, utilizando listas doblemente
{ enlazadas. Los estudiantes aprobados deben
cout<<p->info<<" "; insertarse al inicio y los reprobados por el final de
} la lista. Los datos requeridos por cada estudiante
else son los siguientes: código, nombre, apellidos,
{

4
correo y nota. El programa debe permitir realizar nuevo->sgte = NULL;
las operaciones de: primero = nuevo;
a) Agregar un estudiante. ultimo = nuevo;
b) Buscar un estudiante por código. }
c) Eliminar un estudiante else
d) Total de estudiantes aprobados {
e) Total de estudiantes desaprobados. nuevo->sgte = primero;
primero->ante = nuevo;
#include <iostream> primero = nuevo;
#include <cstdio> }
#include <windows.h> }
#include <conio.h>
#include <string.h> void agregarEstudiante (NodoD* &primero, NodoD*
&ultimo)
using namespace std; {
Estudiante x;
void cabecera() cabecera();
{ cout<<"Ingrese los datos del estudiante:\n";
system("cls"); cout<<"Codigo: ";
cout<<"Bienvenidos al programa de registro de fflush(stdin);
estudiantes\n\n"; cin.getline(x.codigo,10);
} cout<<"Nombre: ";
cin.getline(x.nombre,15);
struct Estudiante cout<<"Apellido: ";
{ cin.getline(x.apellido,15);
char codigo[10]; cout<<"Correo: ";
char nombre[15]; cin.getline(x.correo,25);
char apellido[15]; cout<<"Nota: ";
char correo[25]; cin>>x.nota;
int nota; if (x.nota>=12)
}; {
addAlInicio(primero,ultimo,x);
struct NodoD }
{ else
Estudiante info; {
NodoD* ante; addAlFinal(primero,ultimo,x);
NodoD* sgte; }
}; cout<<"Se agrego el estudiante con exito.";
getch();
void addAlFinal (NodoD* &primero, NodoD* &ultimo, }
Estudiante x)
{ void buscarEstudiante(NodoD* primero)
NodoD* nuevo = new NodoD; {
nuevo->info = x; NodoD* p = primero;
nuevo->sgte = NULL; bool encontrar = false;
if (primero == NULL) char cod[10];
{ cabecera();
nuevo->ante = NULL; cout<<"Ingrese codigo del estudiante: ";
primero = nuevo; fflush(stdin);
ultimo = nuevo; cin.getline(cod,10);
} while (p!=NULL && encontrar==false)
else {
{ if (strcmp(cod,p->info.codigo)==0)
nuevo->ante = ultimo; {
ultimo->sgte = nuevo; cout<<"Nombre: "<<p->info.nombre<<endl;
ultimo = nuevo; cout<<"Apellido: "<<p->info.apellido<<endl;
} cout<<"Correo: "<<p->info.correo<<endl;
} cout<<"Nota: "<<p->info.nota<<endl;
encontrar = true;
void addAlInicio (NodoD* &primero, NodoD* &ultimo, getch();
Estudiante x) }
{ else
NodoD* nuevo = new NodoD; {
nuevo->info = x; p = p->sgte;
nuevo->ante = NULL; }
if (primero == NULL) }
{ if (encontrar == false)

5
 { {
cout<<"No se encontro al estudiante"; int c = 0;
getch(); NodoD* p = primero;
} while (p!=NULL)
} {
if (p->info.nota >=12)
void eliminarEstudiante(NodoD* &primero, NodoD* {
&ultimo) c = c + 1;
{ }
NodoD* p = primero; p = p->sgte;
bool eliminar = false; }
char cod[10]; cout<<"El total de aprobados es: "<<c;
cabecera(); getch();
cout<<"Ingrese codigo del estudiante a eliminar: "; }
fflush(stdin);
cin.getline(cod,10); void totalDesprobados (NodoD* primero)
while (p!=NULL && eliminar==false) {
{ int c = 0;
if (strcmp(cod,p->info.codigo)==0) NodoD* p = primero;
{ while (p!=NULL)
if (p->ante == NULL) {
{ if (p->info.nota <12)
if (p->sgte == NULL) {
{ c = c + 1;
primero = NULL; }
ultimo = NULL; p = p->sgte;
delete p; }
} cout<<"El total de desaprobados es: "<<c;
else getch();
{ }
p->sgte->ante = NULL;
primero = p->sgte; void menuPrincipal(NodoD* &primero, NodoD*
delete p; &ultimo, bool &salir)
} {
} int opcion;
else bool salir2 = false;
{ cabecera();
if (p->sgte == NULL) cout<<"1. Agregar estudiante\n2. Buscar
{ estudiante por codigo\n3. Eliminar estudiante\n";
p->ante->sgte = NULL; cout<<"4. Total de estudiantes aprobados\n5. Total
ultimo = p->ante; de estudiantes desaprobados\n";
delete p; cout<<"6. Salir\n\n";
} cout<<"Ingrese opcion: ";
else cin>>opcion;
{ while (salir2!=true)
p->ante->sgte = p->sgte; {
p->sgte->ante = p->ante; switch(opcion)
delete p; {
} case 1:
} agregarEstudiante(primero,ultimo);
eliminar = true; salir2 = true;
cout<<"Se elimino el estudiante indicado"; break;
getch(); case 2:
} buscarEstudiante(primero);
else salir2 = true;
{ break;
p = p->sgte; case 3:
} eliminarEstudiante(primero,ultimo);
} salir2 = true;
if (eliminar == false) break;
{ case 4:
cout<<"No se encontro al estudiante"; totalAprobados(primero);
getch(); salir2 = true;
} break;
} case 5:
totalDesprobados(primero);
void totalAprobados (NodoD* primero) salir2 = true;

6
 break; {
case 6: int x;
salir2 = true; cabecera();
salir = true; cout<<"Ingrese dato: ";
default: cin>>x;
salir2 = true; addAlFinal(lista,x);
break; cout<<"El dato se ingreso con exito.";
} getch();
} }
}
void buscarEliminar(Nodo* &lista)
int main() {
{ int x;
NodoD* primero = NULL; bool eliminar = false;
NodoD* ultimo = NULL; Nodo* p;
bool salir = false; Nodo* r;
while (salir!=true) cabecera();
{ if (lista!=NULL)
menuPrincipal(primero, ultimo, salir); {
} p = lista->sgte;
return 0; r = lista;
} cout<<"Ingrese dato a eliminar: ";
cin>>x;
7. Crear el siguiente menú para una lista do
simplemente circular {
a) Ingresar un elemento if (p->info == x)
b) Dado un elemento buscarlo si se encuentra {
eliminarlo if (p == p->sgte)
c) Mostrar el número de elementos de la lista {
d) Mostrar todos los elementos de la lista. lista == NULL;
delete p;
#include <iostream> }
#include <conio.h> else
#include <windows.h> {
r->sgte = p->sgte;
using namespace std; delete p;
}
void cabecera() eliminar = true;
{ }
system("cls"); p = p->sgte;
cout<<"---- MENU ----\n\n"; r = r->sgte;
} }
while(p!=lista->sgte && eliminar == false);
struct Nodo if (eliminar == true)
{ {
int info; cout<<"El dato se elimino correctamente";
Nodo* sgte; getch();
}; }
else
void addAlFinal(Nodo* &lista, int x) {
{ cout<<"No se encontro el dato";
Nodo* nuevo = new Nodo; getch();
nuevo->info = x; }
if (lista==NULL) }
{ else
nuevo->sgte = nuevo; {
lista = nuevo; cout<<"La lista se encuentra vacia";
} getch();
else }
{ }
nuevo->sgte = lista->sgte;
lista->sgte = nuevo; void mostrarNElementos (Nodo* lista)
lista = nuevo; {
} Nodo* p;
} int c = 0;
cabecera();
void ingresarDato(Nodo* &lista) if (lista!=NULL)

7
 { break;
p = lista->sgte; case 4:
do mostrarTodo(lista);
{ salir2 = true;
c = c+1; break;
p = p->sgte; case 5:
} salir = true;
while (p!=lista->sgte); salir2 = true;
cout<<"La lista tiene "<<c<<" elementos."; break;
getch(); default:
} salir2 = true;
else break;
{ }
cout<<"La lista se encuentra vacia"; }
getch(); }
}
} int main()
{
void mostrarTodo (Nodo* lista) Nodo* lista = NULL;
{ bool salir = false;
Nodo* p; while (salir!=true)
cabecera(); {
cout<<"---Elementos de la lista---\n"; menuPrincipal(lista, salir);
if (lista!=NULL) }
{ return 0;
p = lista->sgte; }
do
{ 8. N patos están nadando en círculo en un lago. Un
cout<<p->info<<endl; cazador dispara su escopeta y elimina uno a uno
p = p->sgte; los patos de manera aleatoria. Muestre los patos
} sobrevivientes después de cada disparo. Use una
while (p!=lista->sgte); lista enlazada circular.
getch();
} #include <iostream>
else #include <cstdlib>
{ #include <ctime>
cout<<"La lista se encuentra vacia"; #include <conio.h>
getch();
} using namespace std;
}
struct NodoD
void menuPrincipal (Nodo* &lista, bool &salir) {
{ int info;
int opcion; NodoD* ante;
bool salir2 = false; NodoD* sgte;
cabecera(); };
cout<<"1. Ingresar elemento\n2. Buscar y
eliminar\n3. Mostrar numero de elementos\n"; void addAlFinal(NodoD* &lista, int x)
cout<<"4. Mostrar todos los elementos\n5. {
Salir\n\n"; NodoD* nuevo = new NodoD;
cout<<"Ingrese opcion: "; nuevo->info = x;
cin>>opcion; if (lista==NULL)
while (salir2 != true) {
{ nuevo->ante = nuevo;
switch(opcion) nuevo->sgte = nuevo;
{ lista = nuevo;
case 1: }
ingresarDato(lista); else
salir2 = true; {
break; nuevo->ante = lista;
case 2: nuevo->sgte = lista->sgte;
buscarEliminar(lista); lista->sgte->ante = nuevo;
salir2 = true; lista->sgte = nuevo;
break; lista = nuevo;
case 3: }
mostrarNElementos(lista); }
salir2 = true;

8
void crearPatos(NodoD* &lista, int n) }
{
for (int i=0; i<n; i++) void preguntarDisparo(NodoD* &lista, int &n)
{ {
addAlFinal(lista,i+1); char d;
} bool disparo = true;
} while (disparo==true && n>0)
{
void mostrarPatos(NodoD* lista) cout<<"\nDesea realizar un disparo? (S/N): ";
{ cin>>d;
NodoD* p; if (d == 'n' || d == 'N')
cout<<"\n-----Patos nadando en el lago------\n"; {
if (lista!=NULL) disparo = false;
{ }
p = lista->sgte; else
do {
{ if (d=='s' || d=='S')
cout<<" p"<<p->info; {
p = p->sgte; realizarDisparo(lista,n);
} }
while(p!=lista->sgte && lista!=NULL); }
} }
else }
{
cout<<"Ya no quedan patos."; int main()
getch(); {
} srand((unsigned)time(NULL));
} int n;
NodoD* lista = NULL;
void matarPato(NodoD* &lista, int r) cout<<"Ingrese numero de patos: ";
{ cin>>n;
NodoD* p = lista->sgte; crearPatos(lista, n);
for (int i=0; i<(r-1); i++) mostrarPatos(lista);
{ preguntarDisparo(lista,n);
p = p->sgte; return 0;
} }
if (p==p->sgte || p==p->ante)
{ 9. Se tiene una ruleta la cual gira alternado los
lista = NULL; números del 0 al 20, se pulsa una tecla y si sale
delete p; par gana 2 si sale impar pierde 1, si sale 0 pierde
} todo. Gire la ruleta n veces (vez por vez) y muestre
else el monto ganado o perdido. Use una lista enlazada
{ circular
if (p == lista)
{
p->sgte->ante = p->ante;
p->ante->sgte = p->sgte; 10. Consideremos un problema que puede ser
lista = p->ante; resuelto en una forma directa mediante listas
delete p; circulares. El problema se conoce con el nombre
} de José, y consiste en un grupo de soldados
else rodeados por una gran fuerza enemiga. No hay
{ esperanza de victoria si no llegan refuerzos, y
p->sgte->ante = p->ante; existe un solo caballo disponible para el escape.
p->ante->sgte = p->sgte; Los soldados se ponen de acuerdo en un pacto
delete p; para determinar cuál de ellos debe escapar y
} solicita ayuda. Forman un círculo y se escoge un
} número n al azar de un sombrero, igualmente se
} escoge el nombre de un soldado. Comenzando
con el soldado cuyo nombre se ha seleccionado,
void realizarDisparo(NodoD* &lista, int &n) comienzan a contar en la dirección del reloj al
{ rededor del círculo. Cuando la cuenta alcanza n,
int r; este soldado es retirado del círculo y la cuenta
r = rand()%(n)+1; empieza de nuevo, con el siguiente hombre. El
cout<<"\nLe dio al pato en posicion "<<r; proceso continúa de tal manera que cada vez que
matarPato(lista,r); la cuenta alcanza n, se remueve un hombre del
n = n-1; círculo. Un soldado que es removido del círculo
mostrarPatos(lista); por supuesto no se vuelve a contar. El último

9
soldado que queda es el que debe tomar el caballo
y escapar. El problema es: dado un número n, el void numeroDelSombrero(int n, int &r)
ordenamiento de los hombres en el círculo y el {
hombre a partir del que se comienza a contar, r = rand()%n+1;
determinar el orden en el cual los hombres son cout<<"Se saco del sombrero el numero: "<<r;
eliminados del círculo y cual debe escapar. La }
entrada al programa es el número n y una lista de
nombres que es el ordenamiento en el sentido de void nombreDelSoldado(NodoD* lista, NodoD*
las manecillas del reloj en el círculo, comenzando &elegido, int n)
con el hombre a partir del cual se debe comenzar {
a contar. La última línea de entrada contiene int r;
"FIN", indicando el final de la entrada. El programa r = rand()%n;
debe mostrar los nombres de los soldados en el char nombre;
orden que han sido eliminados y el nombre de la NodoD* p = lista;
persona que escapa. for (int i=0; i<r; i++)
{
Por ejemplo, supongamos que n es 3 y que hay 5 p = p->sgte;
hombres denominados A, B, C, D y E. Contamos }
tres hombres partiendo de A, de tal manera que C cout<<"\nEl soldado elegido es "<<p->info;
es eliminado primero. Luego empezamos en D y elegido = p;
contamos D, E y regresamos a A, de tal manera }
que A es eliminado. Después contamos B,D y E (C
ya ha sido eliminado), se elimina E. Finalmente void mostrarPeloton(NodoD* lista)
contamos B,D y B, se elimina B y D es el hombre {
que escapa. NodoD* p;
cout<<"\n\n-----Soldados del peloton JOSE------\n";
#include <iostream> if (lista!=NULL)
#include <ctime> {
#include <conio.h> p = lista->sgte;
#include <cstdlib> do
{
using namespace std; cout<<" sold."<<p->info;
p = p->sgte;
struct NodoD }
{ while(p!=lista->sgte && lista!=NULL);
char info; }
NodoD* ante; }
NodoD* sgte;
}; void eliminarSoldado(NodoD* &lista, NodoD*
&elegido, int r, bool &eliminar)
void addAlFinal(NodoD* &lista, int x) {
{ NodoD* p = elegido->ante;
NodoD* nuevo = new NodoD; for (int i=0; i<(r); i++)
nuevo->info = x; {
if (lista==NULL) p = p->sgte;
{ }
nuevo->ante = nuevo; if (p==p->sgte || p==p->ante)
nuevo->sgte = nuevo; {
lista = nuevo; cout<<"\nEl soldado que escapa es "<<p->info;
} eliminar = false;
else }
{ else
nuevo->ante = lista; {
nuevo->sgte = lista->sgte; if (p == lista)
lista->sgte->ante = nuevo; {
lista->sgte = nuevo; cout<<"\nSe elimino el soldado "<<p->info;
lista = nuevo; p->sgte->ante = p->ante;
} p->ante->sgte = p->sgte;
} elegido = p->sgte;
lista = p->sgte;
void crearPeloton(NodoD* &lista, int n) delete p;
{ }
for (int i=0; i<n; i++) else
{ {
addAlFinal(lista,i+65); cout<<"\nSe elimino el soldado "<<p->info;
} p->sgte->ante = p->ante;
} p->ante->sgte = p->sgte;

10
 elegido = p->sgte;
delete p;
}
}
}

void preguntarSacar(NodoD* lista, NodoD* &elegido,

int &n, int r)
{
char d;
bool eliminar = true;
while (eliminar==true)
{
cout<<"\nEliminar soldado? (S/N): ";
cin>>d;
if (d == 'n' || d == 'N')
{
eliminar = false;
}
else
{
if (d=='s' || d=='S')
{
eliminarSoldado(lista,elegido,r,eliminar);
mostrarPeloton(lista);
}
}
}
}

int main()
{
int n, r;
srand((unsigned)time(NULL));
NodoD* lista = NULL;
NodoD* elegido = NULL;
cout<<"Cuantos hombres hay en el peloton JOSE?
";
cin>>n;
crearPeloton(lista,n);
numeroDelSombrero(n, r);
nombreDelSoldado(lista,elegido,n);
mostrarPeloton(lista);
preguntarSacar(lista,elegido,n,r);
return 0;
}

11. Se ha definido la siguiente estructura de datos:

En el arreglo "POSTRES" se almacenan nombres
de postres. A su vez cada elemento del arreglo
tiene una lista de todos los ingredientes que
requiere dicho postre.
Escribir un programa para:
a) Ingresar un postre con todos sus
ingredientes
b) Dado el nombre de un postre, muestre la lista
de todos sus ingredientes.
c) Dado el nombre de un postre, pueda insertar
nuevos ingredientes a su correspondiente
lista.
d) Dado el nombre de un postre, pueda eliminar
alguno de sus ingredientes.
e) Eliminar un postre con todos sus
ingredientes

11