TALLER

Realizar los siguientes programas:

1. Implementar una función que recibe una lista de enteros L y un número entero n de
forma que modifique la lista mediante el borrado de todos los elementos de la lista
que tengan este valor.

#include <iostream>
#include <stdlib.h>

using namespace std;

struct nodo {
int info;
struct nodo *sig;
};

void crear(struct nodo **);

void insertar(struct nodo **, int);
void eliminar(struct nodo **, int);
void recorrer(struct nodo **);
int recorrer1(struct nodo **, int);

int main() {
struct nodo *ent;
int dato;
crear(&ent);
cout<<"Ingrese valores enteros y cero para terminar"<<endl;

cout<<endl;
cin>>dato;
while(dato != 0)
{
insertar(&ent, dato);
cin>>dato;
}
cout<<endl;
system("pause");
system("cls");
cout<<"el resultado es "<<endl;
cout<<endl;
recorrer(&ent);
cout<<endl;
system("pause");
system("cls");
cout<<"Ingrese dato que desea eliminar "<<endl;
cout<<endl;
cin>>dato;
cout<<endl;
while(recorrer1(&ent,dato)==1)
{
eliminar(&ent, dato);
}
cout<<endl;
 system("pause");
system("cls");
cout<<"la lista es "<<endl;
cout<<endl;
recorrer(&ent);
getchar();
getchar();
return 0;
}

void crear(struct nodo **ent)

{
*ent = NULL;
}

void insertar(struct nodo **ent, int dato)

{
struct nodo *aux, *p, *ant;
aux = new nodo;
if(!aux) { cout<<"error:memoria insuficiente"<<endl; exit(1);}
aux->info = dato;
ant = NULL;
p = *ent;
while((p != NULL) && (p->info < dato))
{
ant = p;
p = p->sig;
}
if(ant == NULL)
{
aux->sig = *ent;
*ent = aux;
}
else
{
ant->sig = aux;
aux->sig = p;
}
}

void eliminar(struct nodo **ent, int dato)

{
struct nodo *p, *ant;
p = *ent;
ant = NULL;
while((p != NULL) && (p->info < dato))

{
ant = p;
p = p->sig;
}
if(p->info != dato) cout<<"dato no existe "<<endl;
else
{
if(ant == NULL)
 *ent = (*ent)->sig;
else
ant->sig = p->sig;

delete p;
}
}

void recorrer(struct nodo **ent)

{
struct nodo *p;
p = *ent;
while(p != NULL)
{
cout<<p->info<<endl;
p = p->sig;
}
}

int recorrer1(struct nodo **ent, int dato)

{
struct nodo *p;
p = *ent;
while((p != NULL) && (p->info < dato)) p = p->sig;
if(p->info == dato)
return 1;
else
return 0;
}
 2. Construir una función que sume los elementos de una lista de enteros.

#include <iostream>
#include <stdlib.h>

using namespace std;

struct nodo {
int info;
struct nodo *sig;
};

void crear(struct nodo **);

void insertar(struct nodo **, int);
void recorrer(struct nodo **);
int suma (int val);

int main() {
struct nodo *ent;
int dato,sum,cont;
cont=0;
crear(&ent);
cout<<"Ingrese valores enteros"<<endl;
cout<<"cero para terminar: "<<endl;
cout<<endl;
cin>>dato;
sum=dato;
cont=cont+dato;
while(dato != 0)
{
insertar(&ent, dato);
cin>>dato;
sum=dato;
cont=cont+dato;
}
cout<<endl;
system("pause");
system("cls");
cout<<"la lista es :"<<endl;
cout<<endl;
recorrer(&ent);
cout<<endl;
system("pause");
system("cls");
cout<<"la suma de toda la lista es: "<<endl;
cout<<endl;
cout<<cont<<endl;
cout<<endl;
getchar();
getchar();
return 0;
}

/******** funciones de listas simplemente enlazadas *********/

void crear(struct nodo **ent)
{
*ent = NULL;
}

void insertar(struct nodo **ent, int dato)

{
struct nodo *aux, *p, *ant;
aux = new nodo;
if(!aux) { cout<<"error:memoria insuficiente"<<endl; exit(1);}
aux->info = dato;
ant = NULL;
p = *ent; //p es el ptro aux que recorre la lista para insertar
ORDENADO
while((p != NULL) && (p->info < dato))
{
ant = p;
p = p->sig;
}
if(ant == NULL)
{
aux->sig = *ent;
*ent = aux;
}
else
{
ant->sig = aux;
aux->sig = p;
}
}

void recorrer(struct nodo **ent)

{
struct nodo *p;
p = *ent;
while(p != NULL)
{
cout<<p->info<<endl;
p = p->sig;
}
}

3. Construir una función imprimeInverso que imprima los elementos de una lista

enlazada de enteros en orden inverso.

#include <iostream>
#include <stdlib.h>

using namespace std;

struct nodo {
int info;
struct nodo *sig;
};

void crear(struct nodo **);

void insertar(struct nodo **, int);
void recorrer(struct nodo **);

int main() {
struct nodo *ent;
int dato;
crear(&ent);
cout<<"Ingrese valores enteros"<<endl;
cout<<"cero para terminar: "<<endl;
cout<<endl;
cin>>dato;
while(dato != 0)
{
insertar(&ent, dato);
cin>>dato;
}
cout<<endl;
system("pause");
system("cls");
cout<<"la lista invertida es: "<<endl;
cout<<endl;
recorrer(&ent);
getchar();
getchar();
return 0;
}

void crear(struct nodo **ent)

{
*ent = NULL;
}

void insertar(struct nodo **ent, int dato)

{
struct nodo *aux, *p, *ant;
aux = new nodo;
if(!aux) { cout<<"error:memoria insuficiente"<<endl; exit(1);}
aux->info = dato;
ant = NULL;
p = *ent;
while((p != NULL) && (p->info > dato))
{
ant = p;
p = p->sig;
}
if(ant == NULL)
{
aux->sig = *ent;
*ent = aux;
} B
{
ant->sig = aux;
 aux->sig = p;
}
}

void recorrer(struct nodo **ent)

{
struct nodo *p;
p = *ent;
while(p != NULL)
{
cout<<p->info<<endl;
p = p->sig;
}
}

4 funcion elimiar en una pila

#include <iostream>
#include <stdlib.h>

using namespace std;

struct nodo {
int info;
struct nodo *sig;
};

void crear(struct nodo **);

void poner(struct nodo **, int);
int sacar(struct nodo **);
int ver(struct nodo **); //veo pero NO elimino
int vacia(struct nodo **); //vacia? booleano 0-1
void recorrer(struct nodo **); //muestro lo que hay ... uso una pila aux
void eliminar(struct nodo **, int);
int main(void) {
struct nodo *tope;
int dato;
crear(&tope);
cout<<"\nIngrese un valor: ";
cin>>dato;
//cargo la pila
while(dato != 0) {
poner(&tope, dato);
cout<<"\nIngrese un valor: ";
cin>>dato;
}
cout<<"Ingrese dato a eliminar: ";
cin>>dato;
eliminar(&tope, dato);
recorrer(&tope);

//saco un elemento
if(vacia(&tope) != 0) {
 dato = sacar(&tope);
cout<<"\nTOPE de la pila: "<<dato<<endl;
}
//recorro la píla
recorrer(&tope);
//vacio la pila
while(vacia(&tope) != 0) sacar(&tope);
//confirmo que esta vacia
if(vacia(&tope) == 0)
cout<<"Pila VACIA "<<endl;
else
cout<<"Pila NO VACIA"<<endl;

getchar();
getchar();
return 0;
}

void crear(struct nodo **tope) {

*tope = NULL;
}

void poner(struct nodo **tope, int dato) {

struct nodo *aux;
aux = new nodo; //new() devuelve un puntero
if(aux == NULL) {
cout<<"Memoria insuficiente..."<<endl;
exit(1);
}
aux->info = dato;
aux->sig = *tope;
*tope = aux;
}

int sacar(struct nodo **tope) {

struct nodo *aux;
int dato;
aux = *tope;
dato = (*tope)->info; //podria ser: dato = aux->info;
*tope = (*tope)->sig; //podria ser: *tope = aux->sig;
delete aux; //libero memoria
return dato;
}

int ver(struct nodo **tope){

return (*tope)->info;
}

int vacia(struct nodo **tope) {

if(*tope == NULL)
return 0;
else
return 1;
}

void recorrer(struct nodo **tope) {

struct nodo *tope_aux;
 int dato;
crear(&tope_aux); //pila AUXILIAR, es LOCAL
while(vacia(tope) != 0) { //vacia(tope) = &(*tope)
dato = sacar(tope);
cout<<dato<<endl;
poner(&tope_aux, dato);
}
//armoa nuevamente la pila:
//quedo al reves y tope no apunta a nada ...
while(vacia(&tope_aux) != 0) {
poner(tope, sacar(&tope_aux));
}
}
void eliminar(struct nodo **tope, int dato)
{
struct nodo *p, *ant;
p = *tope;
ant = NULL;
while((p != NULL) && (p->info < dato))
//si pregunto p->info != dato recorro toda la lista sin sentido
{
ant = p;
p = p->sig;
}
if(p->info != dato) cout<<"dato no existe "<<endl;
else
{
if(ant == NULL) //1er nodo
*tope = (*tope)->sig;
else
ant->sig = p->sig;

delete p;
}
}