Instituto Politcnico Nacional

Escuela Superior de Ingeniera Mecnica y Elctrica

Ingeniera en Comunicaciones y Electrnica
Academia de Computacin
Estructuras y bases de datos
Tema
programas del semestre
Grupo: 3cm13
Integrantes

Hernndez Lpez Luis Fernando

Fecha de entrega; 4 de marzo de 2015

Binario
#include <stdio.h>
#include <iostream>
#include <stdio.h>
#include <conio.h>
using namespace std;
class bin
{
private:
int z,x,n,nn2[50];
public:
bin();
void calculo1();
~bin();
};
bin :: bin()
{
cout<<endl<<" dame un numero "<<endl;
cin>>n;
}
void bin :: calculo1()
{
if(n==1)
cout<<" 0000000";
if(n<0)
{
n=n*-1;
}
nn2[0]=0;
for (x=0;x<50;x++)
{
nn2[x]=n%2;
n=n/2;
if(n==0)
break;
}
for(z=x;z>=0;z--)
{
cout<<nn2[z];
}
}
bin :: ~bin()
{
cout<<endl<<endl<<" destruyendo variables "<<endl;
cout<<endl;
}

main()
{
bin a;
cout<<endl;
a.calculo1();
cout<<endl<<endl;
system("pause");
}

Binario-matiza
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<conio.h>
using namespace std;
class bin
{
private:
int z,x,n,nn2[50],z1,conta,x1,b,n1,nn1[50];
float a;
public:
bin();
void calculo1();
void calculo2();
void calculo3();
~bin();
};
bin :: bin()
{
cout<<endl<<" dame el numero decimal "<<endl;
cin>>a;
conta=0;
b=a;
if(a!=b)
a=a*10;
conta++;
n=a;
n1=conta++;
}
void bin :: calculo1()
{
if(n>0)
cout<<" 0 ";
else

cout<<" 1 ";
}
void bin :: calculo2()
{
nn2[0]=0;
if(n<0)
{
n=n*-1;
}
for (x=0;x<50;x++)
{
nn2[x]=n%2;
n=n/2;
if(n==0)
break;
}
for(z=x;z>=0;z--)
{
cout<<nn2[z];
}
}
void bin :: calculo3()
{
nn1[0]=0;
if(n1<0)
{
n1=n1*-1;
}
for (x1=0;x1<50;x1++)
{
nn1[x1]=n1%2;
n1=n1/2;
if(n1==0)
break;
}
for(z1=x1;z1>=0;z1--)
{
cout<<nn1[z1];
}
}
bin :: ~bin()
{
cout<<endl<<endl<<" destruyendo variables "<<endl;
cout<<endl;
}
main()
{
float b,c,d;
bin a;
cout<<endl<<" signo
"<< "
matiza
"<<"

exponente ";

cout<<endl<<"____________________________________________________________
____________";
cout<<endl;
a.calculo1();
cout<<"
";
a.calculo2();
cout<<"
";
a.calculo3();
cout<<endl<<endl;
system("pause");
}

estructura
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
using namespace std;
struct laptop
{
char modelo[15],fabri[20],tipo[20];

float vel;
float precio,ajo;
};
int main()
{
int n;
laptop *ap;
int i;
cout<<endl<<" teclea el numero de laptops que registraras
"<<endl<<endl;
cin>>n;
ap=new laptop[n];
if(ap==NULL)
cout<<endl<<endl<<" la memoria es insuficiente "<<endl;
for(i=0;i<n;i++)
{
cout<<endl<<" registro de laptop no "<<(i+1);
cout<<endl<<" teclea el modelo de la laptop "<<endl;
fflush(stdin);
gets((ap+i)->modelo);
cout<<endl<<" teclea el fabricante de la laptop "<<endl;
gets((ap+i)->fabri);
cout<<endl<<" teclea el ao de fabricacion "<<endl;
cin>>((ap+i)->ajo);
cout<<endl<<" teclea la velocidad del procesador "<<endl;
cin>>((ap+i)->vel);
cout<<endl<<" teclea el precio de la laptop en pesos mexicanos "<<endl;
cin>>((ap+i)->precio);
}
for(i=0;i<n;i++)
{
cout<<endl<<" registro del laptop no "<<(i+1)<<endl;
cout<<":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::.";
cout<<endl<<" modelo "<<endl;
puts((ap+i)->modelo);
cout<<endl<<" fabricante "<<endl;
puts((ap+i)->fabri);
cout<<endl<<" ao de fabricacion "<<((ap+i)->ajo);
cout<<endl<<"la velocidad maxima del preocesador "<<((ap+i)->vel)<<"
GHz ";
cout<<endl<<" el precio de la laptop es "<<((ap+i)->precio)<<" pesos
"<<endl<<endl;
}
int a;
cout<<endl<<"::::::::::: menu de opciones de busqueda ::::::::::::::::";
cout<<endl<<" 1 : busqueda por costos ( inferior-superior )";
cout<<endl<<" 2 : busqueda por fabricante
";
cout<<endl<<" seleciona una opcion de busqueda "<<endl;
cin>>a;
switch(a)

{
case 1:
{
system("pause");
float inf,sup;
system("cls");
cout<<endl<<" busqueda de laptops por costos "<<endl;
do
{
cout<<endl<<" teclea el precio de rango inferior "<<endl;
cin>>inf;
cout<<endl<<" teclea el precio del rango superior "<<endl;
cin>>sup;
}
while(inf>sup);
int band=0;
for(i=0;i<n;i++)
{
if(((ap+i)->precio>=inf) && ((ap+i)->precio<=sup))
{
band++;
cout<<endl<<"las laptop que cae dentro de esta categoria es "<<endl;
cout<<endl<<"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::."<<endl;
cout<<endl<<" laptop no "<<(i+1)<<endl;
cout<<endl<<" modelo "<<endl;
puts((ap+i)->modelo);
cout<<endl<<" fabricante "<<endl;
puts((ap+i)->fabri);
cout<<endl<<" ao de fabricacion "<<(ap+i)->ajo;
cout<<endl<<" la velocidad maxima del procesador "<<((ap+i)->vel)<<"
GHz ";
cout<<endl<<" el precio de la laptop es "<<(ap+i)->precio<<" pesos Mx
"<<endl;
}
}
if(band==0)
{
cout<<endl<<" no hay laptops en ese rango "<<endl;
system("pause");
}
}
break;
case 2:
{
int x;
char busca[15];
cout<<endl<<" teclea el fabricante que buscas "<<endl;
fflush(stdin);
gets(busca);
for(i=0;i<n;i++)

{
x=strcmp(busca,(ap+i)->fabri);
if(x==0)
{
cout<<endl<<"las laptop que cae dentro de esta categoria es "<<endl;
cout<<endl<<"::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::."<<endl;
cout<<endl<<" laptop no "<<(i+1)<<endl;
cout<<endl<<" modelo "<<endl;
puts((ap+i)->modelo);
cout<<endl<<" fabricante "<<endl;
puts((ap+i)->fabri);
cout<<endl<<" ao de fabricacion "<<(ap+i)->ajo;
cout<<endl<<" la velocidad maxima del procesador "<<((ap+i)->vel)<<"
GHz ";
cout<<endl<<" el precio de la laptop es "<<(ap+i)->precio<<" pesos Mx
"<<endl;
}
else
cout<<endl<<" fabricante no encontrado "<<endl;
}
}
break;
}
system("pause");
return 0;
}

Estructura libros
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct libro
{
char titulo[20];
int paginas;
float precio;
};
int main()
{
int n;
libro *ap;
int i;
cout<<endl<<" cuantos libros deseas registrar "<<endl;
cin>>n;
ap=new libro[n];
if(ap==NULL)
cout<<endl<<" la memoria es insificiente "<<endl;
system("pause");
for(i=0;i<n;i++)
{
cout<<endl<<" libro no "<<(i+1);
cout<<endl<<" cual es el titulo del libro "<<endl;
gets((ap+i)->titulo);
cout<<endl<<" numero de paginas "<<endl;
cin>>((ap+i)->paginas);
cout<<endl<<" cual es el precio "<<endl;
cin>>((ap+i)->precio);
}
float sup,inf;
system("cls");
cout<<endl<<" busqueda de los libros que se encuentran en un rango de
precio "<<endl;
do
{
cout<<endl<<" valor del precio inferior "<<endl;
cin>>inf;
cout<<endl<<" cual es el precio superior "<<endl;
cin>>sup;
}
while(inf>sup);
int bandera=0;
for(i=0;i<n;i++)
{
if(((ap+i)->precio>=inf) && ((ap+i)->precio<=sup))
{

bandera ++;
cout<<endl<<"el libro "<<endl;
puts((ap+i)->titulo);
cout<<endl<<" cuesta "<<(ap+i)->precio<<endl;
}
}
if(bandera==0)
{
cout<<endl<<"nohay ningun libro en el rango "<<endl;
system("pause");
}
return 0;
}
Estructuras palabras
#include<iostream>
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
using namespace std;
class cadena
{
private:
char a[25],a1[25];
int i,n;
public:
cadena();
void lectura();
void longitud();
void palindromo();
void iguales();
void cuenta();
void cadmay();
void compara();
friend void igual(cadena x,cadena y);
~cadena();
};
cadena :: cadena()
{
cout<<endl<<"
"<<endl;
}
void cadena :: lectura()
{
cout<<endl<<endl<<" teclea la cadena de caracteres "<<endl<<endl;
fflush(stdin);
gets(a);
cout<<endl<<" la cadena es "<<a<<endl;
}

void cadena :: longitud( )

{
int x=0;
do
{
if(a[x]!='\0')
x++;
}
while(a[x]!='\0');
cout<<endl<<x;
}

void cadena :: palindromo ()

{
int i=0,j=0;
char *b;
while(*(a+i)) i++;
b=a+i-1;
while(*a==*b)
{
i++;
j--;
if(*a=='\0')break;
if(*a==*b)
cout<<" 0" ;
break;
cout<<"\b\b\b\b";
}
cout<<" 1 ";
}

void cadena :: cuenta ()

{
int i=0;
int j=0;
while(a[i]!='\0')
{
a[i]=tolower(a[i]);
if(a[i]=='a'||a[i]=='e'||a[i]=='i'||a[i]=='o'||a[i]=='u')
{
j++;
}
i++;

}
cout<<" contiene : "<<j<<" "<<"Vocales"<<endl;
system("pause");
}
void cadena :: cadmay ()
{
int i=0,j=0;
while(*(a+i))
{
if(a[i]>='a' && a[i]<='z')
a[i]=a[i]-32;
i++;
}
cout<<endl<<a;
}
cadena ::~ cadena()
{
cout<<endl<<" destruyendo variables "<<endl;
}
int main()
{
cadena a,b;
int r;
do
{
cout<<endl<<endl<<" menu de opciones de las cadenas "<<endl<<endl;
cout<<endl<<"
1) calculo de la longitud de cadena "<<endl;
cout<<endl<<"
2) palindromo
"<<endl;
cout<<endl<<"
3) comparar las cadenas "<<endl;
cout<<endl<<"
4) cuenta las vocales de una cadena "<<endl;
cout<<endl<<"
5) pasa de minusculas a mayusculas "<<endl;
cout<<endl<<" selecciona una de las opcciones "<<endl;
cin>>r;
switch(r)
{
case 1:
{
a.lectura();
cout<<endl<<" la longitud de la cadena es "<<endl;
a.longitud();
}
break;
case 2:
{
a.lectura();
cout<<endl<<" el resultado "<<endl;
a.palindromo();
}
break;

case 3:
{
a.lectura();
b.lectura();
cout<<endl<<" el resultado "<<endl;
igual(a,b);
}
break;
case 4:
{
a.lectura();
cout<<endl<<" el resultado "<<endl;
a.cuenta();
}
break;
case 5:
{
a.lectura();
cout<<endl<<" el resultado "<<endl;
a.cadmay();
}
break;
default:
cout<<endl<<" la opccion no es valida "<<endl;
}
char a;
cout<<endl<<" deseas repetir el proceso presiona s "<<endl;
cin>>a;
}
while('a'=='s'||'a'=='s');
system("pause");
}

Lista simplemente enlazada

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<math.h>
using namespace std;
class LISTA;
class NODO
{
int dato,edad;
char nombre[20];
NODO *siguiente;
public:
NODO(int D=0,NODO *s=NULL,char d[20]=" ",int e=0)
{
dato=D;
siguiente=s;
strcpy(nombre,d);
edad=e;
}
friend class LISTA;
};
class LISTA
{
NODO *Lista;
public:
LISTA();
void insertar(char *nom);
void recorrer();
int buscar(int b);
void buscar2(int g);
void borrar(int x);
void buscar3(int i,int s);
void buscar4(char d[20]);
~LISTA();
};
LISTA :: LISTA()
{
Lista=NULL;
}
void LISTA :: buscar2(int g)
{
NODO *aux,*anterior;
aux=Lista;
if(aux->dato==g)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<" nombre :"<<aux->nombre<<endl;

cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<" numero seguro social "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(aux->dato==g)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<" nombre :"<<aux->nombre<<endl;
cout<<endl<<" edad :"<<aux->edad<<endl;
cout<<endl<<" numero seguro social "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
}
cout<<endl<<" el dato no se encontro en la base de datos "<<endl;
system("pause");
}
void LISTA :: insertar(char *nom)
{
int D,e,x;
NODO *aux;
cout<<endl<<" teclea el nombre de la persona "<<endl;
fflush(stdin);
gets(nom);
cout<<endl<<" teclea la edad de la persona "<<endl;
cin>>e;
cout<<endl<<endl<<" teclea el numero de seguro social "<<endl;
cin>>D;
x=strcmp(nom,Lista->nombre);
if(Lista==NULL||x>0)
{
Lista=new NODO(D,Lista,nom,e);
}
else
{
aux=Lista;
while(aux->siguiente && strcmp(aux->siguiente->nombre,nom)<=0 )
{
aux=aux->siguiente;
aux->siguiente=new NODO(D,Lista,nom,e);
}
}

if(aux==NULL)
{
cout<<endl<<" la memoria actual no es insuficiente "<<endl<<endl;
system("pause");
return;
}
Lista=aux;
}
void LISTA :: buscar3(int i,int s)
{
NODO *aux,*anterior;
aux=Lista;
if(aux->edad>=i && aux->edad<=s)
{
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(aux->edad>=i && aux->edad<=s)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
aux=anterior;
anterior=aux->siguiente;
}
cout<<endl<<"el dato no se encontro en el intervalo especificado "<<endl;
}
void LISTA :: recorrer()
{
NODO *aux;
aux=Lista;
while(aux)
{
cout<<endl<<"nombre :"<<aux->nombre<<endl;
cout<<endl<<"seguro social :"<<aux->dato<<endl;
cout<<endl<<"___________________________________________________-"<<endl
;
aux=aux->siguiente;
}

}
int LISTA :: buscar(int b)
{
NODO *aux;
aux=Lista;
while(aux)
{
if(aux->dato==b)
return 1;
aux=aux->siguiente;
}
return 0;
}
void LISTA :: borrar(int x)
{
NODO *aux,*anterior;
aux=Lista;
if(aux==NULL)
{
cout<<endl<<" la lista esta vacia por por lo que no se borrara ningun dato
"<<endl;
system("pause");
return;
}
if(aux->dato==x)
{
Lista=Lista->siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(aux->dato==x)
{
anterior->siguiente=aux->siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->siguiente;
}
cout<<endl<<" el dato que se intento borrar no se encuantra por lo que no
se borro"<<endl;
system("pause");
}
LISTA :: ~LISTA()
{
NODO *aux;

aux=Lista;
while(aux)
{
Lista=Lista->siguiente;
delete aux;
aux=Lista;
}
}
void LISTA :: buscar4(char d[20])
{
int x;
NODO *aux,*anterior;
aux=Lista;
x=strcmp(aux->nombre,d);
if(x==0)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
x=strcmp(aux->nombre,d);
if(x==0)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
}
system("pause");
}
int main()
{
int a;
char numbre[20];
LISTA A;
do
{
system("cls");

cout<<endl<<"------------------menu de opciones
---------------------------------------"<<endl;
cout<<endl<<"-----------------1)insertar dato en la base de datos
---------------------"<<endl;
cout<<endl<<"-----------------2)recorrer la base de
datos------------------------------"<<endl;
cout<<endl<<"-----------------3)verificar la existencia de un dato
--------------------"<<endl;
cout<<endl<<"-----------------4)borrar un dato de la base de datos
--------------------"<<endl;
cout<<endl<<"-----------------5)buscar un dato por su numero
--------------------------"<<endl;
cout<<endl<<"-----------------6)salir del
programa-------------------------------------"<<endl;
cout<<endl<<"-----------------7)buscar datos por rango de edad
------------------------"<<endl;
cout<<endl<<"-----------------8)busqueda por
nombre------------------------------------"<<endl;
cout<<endl<<"----------------selecciona una opcion de las disponibles
-----------------"<<endl;
cin>>a;
switch(a)
{
case 1:
char *nom;
cout<<endl<<"teclea el nombre de la persona"<<endl;
fflush(stdin);
gets(nom);
A.insertar(nom);
break;
case 2:
A.recorrer();
break;
case 3:
cout<<endl<<" teclea al dato que buscas"<<endl;
cin>>a;
if(A.buscar(a))
cout<<endl<<" el dato existe "<<endl;
else
cout<<endl<<" el dato no existe "<<endl;
break;
case 4:
cout<<endl<<" teclea el dato que deseas borrar "<<endl;
cin>>a;
A.borrar(a);
break;
case 5:
cout<<endl<<" teclea el numerod de busqueda "<<endl;
cin>>a;
A.buscar2(a);

break;
case 7:
int inf,sup;
do
{
cout<<endl<<"------ busqueda por rango de edad "<<endl;
cout<<endl<<" teclea el rango inferior de busqueda "<<endl;
cin>>inf;
cout<<endl<<" teclea el valor de busqueda superior "<<endl;
cin>>sup;
}
while(inf>sup);
A.buscar3(inf,sup);
break;
case 8:
cout<<endl<<" teclea el nombre de busqueda "<<endl;
fflush(stdin);
gets(numbre);
A.buscar4(numbre);
break;
case 6:
cout<<endl<<"............hasta la proxima"<<endl;
return 0;
default:
cout<<endl<<" la tecla precionada no es valida "<<endl;
}
system("pause");
}
while(1);
}

Lista simplemente enlazada

#include<iostream>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
using namespace std;
class LISTA;
class NODO
{
char dato[128];
NODO *siguiente;
public:
NODO(char D[128]=" ",NODO *S=NULL)
{
strcpy(dato,D);
siguiente=S;
}
friend class LISTA;
};
class LISTA
{
NODO *Lista;
public:
LISTA();
void insertar();
void recorrer();
void buscar(char *d);
void borrar(char *x);
~LISTA();
};
LISTA :: LISTA()
{
Lista=NULL;
}
void LISTA :: insertar()
{
char D[128];
NODO *aux;
cout<<"teclea el entero que guardaras "<<endl;
fflush(stdin);
gets(D);
aux=new NODO(D,Lista);
if(aux==NULL)
{

cout<<endl<<endl<<" la memoria no es suficientes "<<endl;

system("pause");
return;
}
Lista=aux;
}
void LISTA :: recorrer()
{
NODO *aux;
aux=Lista;
system("cls");
while(aux)
{
cout<<endl<<aux->dato<<endl;
aux=aux->siguiente;
}
cout<<endl<<" NULL"<<endl;
}
void LISTA :: buscar(char *d)
{
int x;
NODO *aux,*anterior;
aux=Lista;
x=strcmp(Lista->dato,d);
if(x==0)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
x=strcmp(d,Lista->dato);
if(x==0)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
}
system("pause");
}
void LISTA :: borrar(char *x)
{

NODO *aux,*anterior;
aux=Lista;
int y;
if(aux==NULL)
{
cout<<endl<<" la lista esta vacia "<<endl;
system("pause");
return;
}
y=strcmp(x,Lista->dato);
if(y==0)
{
Lista=Lista->siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(y==0)
{
anterior->siguiente=aux->siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->siguiente;
}
cout<<endl<<" el dato no se encontro "<<endl;
}
LISTA :: ~LISTA()
{
NODO *aux;
aux=Lista;
while(aux)
{
Lista=Lista->siguiente;
delete aux;
aux=Lista;
}
}
int main()
{
char a[128];
int z;
LISTA A;
do
{
system("cls");

cout<<endl<<" el menu de opciones de esta base de datos es "<<endl;

cout<<endl<<" 1) insertar un dato "<<endl;
cout<<endl<<" 2) recorrer la lista "<<endl;
cout<<endl<<" 3) buscar si existe un dato"<<endl;
cout<<endl<<" 4) borrar un dato si es que existe "<<endl;
cout<<endl<<" 5) salir del programa
"<<endl;
cout<<endl<<" cual es la opcion que desea "<<endl;
cin>>z;
switch(z)
{
case 1:
A.insertar();
break;
case 2:
A.recorrer();
break;
case 3:
cout<<endl<<" cual es el dato que deseas buscar si existe
"<<endl<<endl;
fflush(stdin);
gets(a);
A.buscar(a);
break;
case 4:
cout<<endl<<" teclea el dato que desees eliminar "<<endl;
fflush(stdin);
gets(a);
A.borrar(a);
break;
case 5:
cout<<endl<<" gracias suerte "<<endl;
return 0;
default:
cout<<endl<<" la opcion que seleccionaste no es valida "<<endl;
}
system("pause");
}
while(1);
}
Lista simplemente enlazada con nombres ordenados
#include<iostream>
#include<conio.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
using namespace std;
class Nodo

{
char Nombre[20];
Nodo *Siguiente;
public:
Nodo(char *N=" ",Nodo*S=NULL)
{
strcpy(Nombre,N);
Siguiente=S;
}
friend class Lista;
};
class Lista
{
char Nombre[20];
Nodo *Inicio;
public:
Lista();
void insertar();
int buscar();
void recorrer();
void borrar();
~Lista();
};
Lista::Lista()
{
Inicio=NULL;
}
void Lista::insertar()
{
char N[20];
int x;
Nodo*Aux;
Aux=Inicio;
fflush(stdin);
cout<<"Teclee el Nombre: ";
gets(N);
if(Aux!=NULL)
x=strcmp(N,Inicio->Nombre);
if(Inicio==NULL||x<0)
Inicio=new Nodo(N,Inicio);
else
{
Aux=Inicio;
if(Aux->Siguiente!=NULL)
x=strcmp(Aux->Nombre,N);
while((Aux->Siguiente)&&(x!=0)){
Aux=Aux->Siguiente;

x=strcmp(Aux->Nombre,N);
}
Aux->Siguiente=new Nodo(N,Aux->Siguiente);
}
cout<<"Nombre insertado..."<<endl;
system("pause");
}
int Lista::buscar()
{
char B[20];
Nodo*aux;
aux=Inicio;
cout<<"Que nombre busca"<<endl;
fflush(stdin);
gets(B);
int x;
x= strcmp(B,aux->Nombre);
if(x==0)
{
return 1;
aux=aux->Siguiente;
}
return 0;
}
void Lista::recorrer()
{
Nodo *aux;
aux=Inicio;
while(aux)
{
puts(aux->Nombre);
cout<<"---> ";
aux=aux->Siguiente;
}
cout<<"NULL"<<endl;
system ("pause");
}
void Lista::borrar()
{
char B[20];
int x;
Nodo *aux,*anterior;
aux=Inicio;
cout<<"Que Nombre desea borrar"<<endl;
fflush(stdin);
gets(B);

if(aux==NULL)
{
cout<<" LA LISTA ESTA VACIA "<<endl;
system("pause");
return;
}
x=strcmp(aux->Nombre,B);
if(x==0)
{
Inicio=Inicio->Siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->Siguiente;
while(aux)
{
x=strcmp(aux->Nombre,B);
if(x==0)
{
anterior->Siguiente=aux->Siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->Siguiente;
}
cout<<" El Nombre ha sido Borrado "<<endl;
system("pause");
}
Lista::~Lista()
{
Nodo*aux;
aux=Inicio;
while(aux)
{
Inicio=aux->Siguiente;
delete aux;
}
aux=Inicio;
}
main ()
{
Lista A;
int b;
char a[20];
do{
system("cls");

cout<<"
cout<<"
cout<<"
cout<<"
cout<<"
cout<<"

1.2.3.4.5.-

Lista ordenada de nombres

"<<endl;
Insertar un Nombre
"<<endl;
Borrar Nombre
"<<endl;
Verificar que exista el Nombre
"<<endl;
Recorrer la lista de nombres
"<<endl;
Salir
"<<endl;

cout<<"Ingrese el numero de la opcion que desea: ";

cin>>b;
switch(b)
{
case 1:
A.insertar();
break;
case 2:
A.borrar();
break;
case 3:
if(A.buscar())
{
cout<<"Si Existe..."<<endl;
system("pause");
}
else
{
cout<<"No existe..."<<endl;
system("pause");
}
break;
case 4:
A.recorrer();
break;
case 5:
cout<<"Hasta luego, un placer atenderle"<<endl;
system("pause");
return 0;
default:
cout<<"Opcion no valida"<<endl;
system("pause");
}
}while(1);
}

Lista doblemente enlazada

#include<iostream>
#include<conio.h>
#include<stdlib.h>
#include<ctype.h>
#include<string.h>
#include<stdio.h>
using namespace std;
#define Ascendente
#define Descendente
class nodo{
char dato[50];
nodo *Siguiente;

public:
nodo(char *V=" ",nodo *sig=NULL){
strcpy(dato,V);
Siguiente=sig;
}
friend class Lista;
};
typedef nodo *pnodo;
class Lista{
pnodo actual;
public:
Lista(){actual=NULL;}
~Lista();
void insertar(char *V);
void Borrar(char *V);
bool ListaVacia(){return actual==NULL;}
void Mostrar();
void Siguiente(){
if(actual)
actual=actual->Siguiente;

}
bool Actual(){
return actual!=NULL;
}
char *ValorActual(pnodo aux){
return aux->dato;}
};
Lista::~Lista(){
pnodo Nodo;
while(actual->Siguiente!=actual){
Nodo =actual->Siguiente;
actual->Siguiente=Nodo->Siguiente;
actual->Siguiente=Nodo->Siguiente;
delete Nodo;
}
delete actual;
actual=NULL;
}
void Lista::insertar(char *v){
pnodo Nodo;
Nodo=new nodo(v);
if(actual==NULL)
actual=Nodo;
else
Nodo->Siguiente=actual->Siguiente;
actual->Siguiente=Nodo;
}
void Lista::Borrar(char *V){
pnodo Nodo;
Nodo=actual;
do{
if(strcmp(actual->Siguiente->dato,V)!=0)
Siguiente();
}
while (strcmp(actual->Siguiente->dato,V)!=0&&actual!
=Nodo);
if (strcmp(actual->Siguiente->dato,V)==0){
if(actual==actual->Siguiente){
delete actual;
actual=NULL;
}

else {
Nodo=actual->Siguiente;
actual->Siguiente;
actual->Siguiente=Nodo->Siguiente;
delete Nodo;
}
}
else
cout<<"No existe";
}

void Lista::Mostrar(){
pnodo Nodo=actual;
if(actual==NULL){
cout<<"Lista vacia"<<endl;
return ;
}
do{
cout<<"->";
puts(ValorActual(Nodo));
Nodo=Nodo->Siguiente;
}
while (Nodo!=actual);
cout<< endl;
}
int main(){

Lista L;
char opcion;
char Nombre[50];
for(;;){
system("cls");
cout<< "Menu de lista Circular\n"<<endl;
cout<< "a)Insertar \n"<<endl;
cout<< "b)Borrar \n"<<endl;
cout<< "c)Mostrar \n"<<endl;
cout<< "d)salir \n"<<endl;
cout<< "Cual opcion desea?"<<endl;
opcion=getche();
opcion =tolower (opcion);
system("cls");{

switch(opcion){
case 'a':
cout<<"Nombre a Insertar?"<<endl;
fflush(stdin);
gets(Nombre);
L.insertar (Nombre);
cout<< "Nombre Insertado \n";
system("pause");
break;
case 'b':
cout<<"Nombre a Borrar \n";
fflush(stdin);
gets(Nombre);
L.Borrar(Nombre);
system ("pause");
break;

case 'c':
L.Mostrar();
system("pause");
break;
case 'd':
cout<<"Programa terminado"<<endl;
system("pause");
return 0;
}
}

}
}
Lista circular
#define ASCENDENTE 1
#define DESCENDENTE 0
#include<iostream>
#include<stdio.h>

#include<conio.h>
#include<string.h>
#include<stdlib.h>
using namespace std;
class nodo
{
public:
nodo(int v=0, nodo*sig=NULL,
nodo*ant=NULL):valor(v),siguiente(sig),anterior(ant){}
private:
int valor;
nodo *siguiente;
nodo *anterior;
friend class lista;
};
typedef nodo*pnodo;
class lista
{
public:
lista():plista(NULL){}
~lista();
void Insertar(int v);
void Borrar(int v);
bool ListaVacia(){return plista==NULL;}
void Mostrar(int);
void Siguiente();
void Anterior();
void Primero();
void Ultimo();
bool Actual(){return plista != NULL;}
int ValorActual(){return plista->valor;}
private:
pnodo plista;
};
lista::~lista()
{
pnodo aux;
Primero();
while(plista)
{
aux=plista;
plista=plista->siguiente;
delete aux;
}
}

void lista::Insertar(int v)
{
pnodo nuevo;
Primero();
if(ListaVacia()||plista->valor>v)
{
nuevo=new nodo(v,plista);
if(!plista)plista=nuevo;
else plista ->anterior=nuevo;
}
else
{
while(plista->siguiente&&plista->siguiente->valor<=v)Siguiente();
nuevo=new nodo(v,plista->siguiente,plista);
plista->siguiente= nuevo;
if(nuevo->siguiente)nuevo->siguiente->anterior=nuevo;
}
cout<<"DATO INSERTADO "<<endl;
return;
}
void lista::Borrar(int v)
{
pnodo Nodo;
Nodo=plista;
while(Nodo&&Nodo->valor<v)Nodo=Nodo->siguiente;
while(Nodo&&Nodo->valor>v)Nodo=Nodo->anterior;
if(!Nodo||Nodo->valor!=v)return;
if(Nodo->anterior)Nodo->anterior->siguiente=Nodo->siguiente;
if(Nodo->siguiente)Nodo->siguiente->anterior=Nodo->anterior;
delete Nodo;
}
void lista::Mostrar(int o)
{
pnodo aux;
if(o==1)
{
cout<<"Ascendente "<<endl;
Primero();
aux=plista;
if(aux==NULL)
{
cout<<"LISTA VACIA "<<endl;
return;
}
while(aux)
{
cout<<aux->valor<<"-->"<<endl;
aux=aux->siguiente;

}
cout<<endl;
}
else
{
cout<<"Descendente "<<endl;
Ultimo();
aux=plista;
if(aux==NULL)
{
cout<<"LISTA VACIA "<<endl;
return;
}
while(aux)
{
cout<<aux->valor<<"<--"<<endl;
aux=aux->anterior;
}
cout<<endl;
}
}
void lista::Siguiente()
{
if(plista!=NULL&&plista->siguiente)plista=plista->siguiente;
}
void lista::Anterior()
{
if(plista!=NULL&&plista->anterior)plista=plista->anterior;
}
void lista::Ultimo()
{
while(plista&&plista->siguiente)plista=plista->siguiente;
}
void lista::Primero()
{
while(plista&&plista->anterior)plista=plista->anterior;
}
main()
{
lista a;
int x,o,v;
do
{
system("cls");
cout<<" LISTA DOBLEMENTE ENLAZADA "<<endl;

cout<<" "<<endl;
cout<<"Elije una opcion: "<<endl;
cout<<"1) Ingresar Dato "<<endl;
cout<<"2) Borrar Dato "<<endl;
cout<<"3) Mostrar "<<endl;
cout<<"4) Salir "<<endl;
cin>>x;
switch (x)
{
case 1:
system("cls");
cout<<"Que dato ingresa? "<<endl;
cin>>v;
a.Insertar(v);
system("pause");
break;
case 2:
system("cls");
cout<<"Que dato borra? "<<endl;
cin>>v;
a.Borrar(v);
system("pause");
break;
case 3:
system("cls");
cout<<"Mostrar Ascendente =1 "<<endl;
cout<<"Mostrar Descendente =0 "<<endl;
cout<<"Elija una opcin: "<<endl;
cin>>o;
a.Mostrar(o);
system("pause");
break;
case 4:
cout<<"FIN DEL PROGRAMA... "<<endl;
system("pause");
break;
default:
cout<<"OPCION INVALIDA "<<endl;
system("pause");
break;
}
}
while(4);
getch();
}

Lista simple con multiples opciones

#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<fstream>
#include<iostream>
#include<stdio.h>
using namespace std;
class LISTA;
class NODO
{
int dato,edad;
char nombre[20];
NODO *siguiente;
public:
NODO(int D=0,char d[20]=" ",int e=0,NODO *s=NULL)
{
dato=D;
siguiente=s;
edad=e;
strcpy(nombre,d);
}
friend class LISTA;
};
class LISTA
{
NODO *Lista;
public:
LISTA();
void insertar(int d=0,char *nom="",int e=0);
void recorrer();
int buscar(int b);
void buscar2(int g);
void borrar(int x);
void buscar3(int i,int s);

void buscar4(char d[20]);

void Guardar();
void Recuperar();
~LISTA();
};
LISTA :: LISTA()
{
Lista=NULL;
}
void LISTA :: Guardar()
{
NODO *aux;
aux=Lista;
char Nombre_archivo[128];
cout<<endl<<"nombre del archivo a guardar "<<endl;
gets(Nombre_archivo);
ofstream archivo_salida (Nombre_archivo);
if(archivo_salida.fail())
{
cout<<endl<<"error al abrir el archivo"<<endl;
system("pause");
return;
}
while(aux)
{
archivo_salida<<aux->dato<<" "<<aux->edad<<" "<<aux>nombre<<endl;
aux=aux->siguiente;
}
cout<<endl<<"archivo guardado "<<endl;
system("pause");
archivo_salida.close();
}
void LISTA :: buscar2(int g)
{
NODO *aux,*anterior;
aux=Lista;
if(aux->dato==g)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<" nombre :"<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<" numero seguro social "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{

if(aux->dato==g)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<" nombre :"<<aux->nombre<<endl;
cout<<endl<<" edad :"<<aux->edad<<endl;
cout<<endl<<" numero seguro social "<<aux->dato<<endl;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
}
cout<<endl<<" el dato no se encontro en la base de datos "<<endl;
system("pause");
}
void LISTA :: insertar(int D,char *nom,int e)
{
NODO *aux=Lista;
aux=new NODO(D,nom,e,Lista);
if(aux==NULL)
{
cout<<endl<<" la memoria actual no es insuficiente "<<endl<<endl;
system("pause");
return;
}
Lista=aux;
}
void LISTA :: buscar3(int i,int s)
{
NODO *aux,*anterior;
aux=Lista;
if(aux->edad>=i && aux->edad<=s)
{
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(aux->edad>=i && aux->edad<=s)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;

anterior->siguiente=aux->siguiente;
}
aux=anterior;
anterior=aux->siguiente;
}
cout<<endl<<"el dato no se encontro en el intervalo especificado "<<endl;
}
void LISTA :: recorrer()
{
NODO *aux;
aux=Lista;
while(aux)
{
cout<<endl<<"nombre :"<<aux->nombre<<endl;
cout<<endl<<" edad: "<<aux->edad<<endl;
cout<<endl<<"seguro social :"<<aux->dato<<endl;
cout<<endl<<"___________________________________________________-"<<endl
;
aux=aux->siguiente;
}
}
int LISTA :: buscar(int b)
{
NODO *aux;
aux=Lista;
while(aux)
{
if(aux->dato==b)
return 1;
aux=aux->siguiente;
}
return 0;
}
void LISTA :: borrar(int x)
{
NODO *aux,*anterior;
aux=Lista;
if(aux==NULL)
{
cout<<endl<<" la lista esta vacia por por lo que no se borrara ningun dato
"<<endl;
system("pause");
return;
}
if(aux->edad==x)
{
Lista=Lista->siguiente;
delete aux;
return;
}

anterior=aux;
aux=aux->siguiente;
while(aux)
{
if(aux->edad==x)
{
anterior->siguiente=aux->siguiente;
delete aux;
return;
}
anterior=aux;
aux=aux->siguiente;
}
cout<<endl<<" el dato que se intento borrar no se encuantra por lo que no
se borro"<<endl;
system("pause");
}
LISTA :: ~LISTA()
{
NODO *aux;
aux=Lista;
while(aux)
{
Lista=Lista->siguiente;
delete aux;
aux=Lista;
}
}
void LISTA :: buscar4(char d[20])
{
int x;
NODO *aux,*anterior;
aux=Lista;
x=strcmp(aux->nombre,d);
if(x==0)
{
cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;
aux=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
while(aux)
{
x=strcmp(aux->nombre,d);
if(x==0)
{

cout<<endl<<"-------------------------------------"<<endl;
cout<<endl<<"nombre "<<aux->nombre<<endl;
cout<<endl<<"edad "<<aux->edad<<endl;
cout<<endl<<"seguro social "<<aux->dato;
cout<<endl<<"-------------------------------------"<<endl;
anterior->siguiente=aux->siguiente;
}
anterior=aux;
aux=aux->siguiente;
}
system("pause");
}
void LISTA:: Recuperar()
{
NODO *aux;
int f,g;
char *dato;
FILE *archivo_entrada;
archivo_entrada=fopen("datos.txt","r");
if(!archivo_entrada)
{
cout<<endl<<" error al abrir el archivo "<<endl;
system("pause");
return;
}
while(!feof(archivo_entrada))
{
fscanf(archivo_entrada,"%d %s %d",f,dato,g);
insertar(f,dato,g);
}
cout<<endl<<" archivo recuperado "<<endl;
system("pause");
fclose(archivo_entrada);
}
int main()
{
char opcion;
char numbre[20];
LISTA A;
do
{
system("cls");
cout<<endl<<"------------------menu de opciones de base de datos
----------------------"<<endl;
cout<<endl<<"-----------------a)insertar datos en la base de datos
--------------------"<<endl;
cout<<endl<<"-----------------b)recorrer la base de
datos------------------------------"<<endl;
cout<<endl<<"-----------------c)busqueda de datos
-------------------------------------"<<endl;

cout<<endl<<"-----------------d)borrar un dato por edad de la base de datos

-----------"<<endl;
cout<<endl<<"-----------------e)guardar lista en un archivo
externo--------------------"<<endl;
cout<<endl<<"-----------------f)recuperar lista de un archivo
externo------------------"<<endl;
cout<<endl<<"-----------------g)salir del
programa-------------------------------------"<<endl;
cout<<endl<<"----------------selecciona una opcion de las disponibles
-----------------"<<endl;
opcion=getche();
opcion=tolower(opcion);
switch(opcion)
{
case 'a':
int Der,esp;
char nomer[20];
cout<<endl<<" teclea el nombre de la persona "<<endl;
fflush(stdin);
gets(nomer);
cout<<endl<<" teclea la edad de la persona "<<endl;
cin>>esp;
cout<<endl<<endl<<" teclea el numero de seguro social "<<endl;
cin>>Der;
A.insertar(Der,nomer,esp);
break;
case 'b':
A.recorrer();
break;
case 'c':
{
system("cls");
int a;
cout<<endl<<" opciones de la base de datos de busqueda "<<endl;
cout<<endl<<" 1)verificar la existencia de un dato (numero de seguro
social "<<endl;
cout<<endl<<" 2)buscar un dato por el numero de su seguro social
"<<endl;
cout<<endl<<" 3)buscar un dato por el rango de edad "<<endl;
cout<<endl<<" 4)buscar por el nombre "<<endl;
cout<<endl<<" 5)salir del programa (alternativa) "<<endl;
cout<<endl<<" teclea la opcion que deseas "<<endl;
cin>>a;
switch(a)
{
case 1:
cout<<endl<<" teclea al dato que buscas"<<endl;
cin>>a;
if(A.buscar(a))
cout<<endl<<" el dato existe "<<endl;

else
cout<<endl<<" el dato no existe "<<endl;
break;
case 2:
cout<<endl<<" teclea el numero de seguro social de busqueda "<<endl;
cin>>a;
A.buscar2(a);
break;
case 3:
int inf,sup;
do
{
cout<<endl<<"------ busqueda por rango de edad "<<endl;
cout<<endl<<" teclea el rango inferior de busqueda "<<endl;
cin>>inf;
cout<<endl<<" teclea el valor de busqueda superior "<<endl;
cin>>sup;
}
while(inf>sup);
A.buscar3(inf,sup);
break;
case 4:
cout<<endl<<" teclea el nombre de busqueda "<<endl;
fflush(stdin);
gets(numbre);
A.buscar4(numbre);
break;
case 5:
return 0;
break;
default:
cout<<endl<<" la opcion no es valida "<<endl;
}
}
break;
case 'd':
int a;
cout<<endl<<" teclea el dato (edad )que deseas borrar "<<endl;
cin>>a;
A.borrar(a);
break;
case 'e':
fflush(stdin);
A.Guardar();
break;
case 'f':
A.Recuperar();
break;
case 'g':
cout<<endl<<"............hasta la proxima"<<endl;

return 0;
default:
cout<<endl<<" la tecla precionada no es valida "<<endl;
}
system("pause");
}
while(1);
}

Lista con guardado externo

#include<fstream>
#include<conio.h>
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
using namespace std;
class Nodo{
char Nombre[128];
Nodo *siguiente;
public:
Nodo(char *N="",Nodo*S=NULL){
strcpy(Nombre,N);
siguiente=S;
}
friend class Lista;
};

class Lista{
Nodo *inicio;
public:
Lista(){
inicio=NULL;
}
void Insertar(char*);
void Guardar();
void Recuperar();
void Recorrer();
};
void Lista::Insertar(char*N){
Nodo*nuevo=inicio;
nuevo= new Nodo(N,inicio);
inicio=nuevo;
system("pause");
}
void Lista::Guardar(){
Nodo *aux=inicio;
char Nombre_archivo[128];
cout<<endl<<"Nombre del archivo a guardar...";
gets(Nombre_archivo);
ofstream archivo_salida(Nombre_archivo);
if (archivo_salida.fail()){
cout<<"ERROR AL ABRIR EL ARCHIVO..."<<endl;
system("pause");
return;
}
while (aux){
archivo_salida<<aux->Nombre<<endl;
aux=aux->siguiente;
}
cout<<"ARCHIVO GUARDADO..."<<endl;
system("pause");
archivo_salida.close();
}
void Lista::Recuperar(){
Nodo*aux;
char Nombre_archivo[128];
char dato[128];
cout<<endl<<"Nombre del archivo a recuperar...";
gets(Nombre_archivo);
ifstream archivo_entrada(Nombre_archivo);
if(archivo_entrada.fail()){
cout<<"ERROR AL ABRIR EL ARCHIVO...";
system("pause");

return;
}
while(inicio){
aux=inicio;
inicio=inicio->siguiente;
delete aux;
}
while(!archivo_entrada.eof()){
archivo_entrada.getline(dato, sizeof(dato));
Insertar(dato);
}
aux=inicio;
inicio=inicio->siguiente;
delete aux;
cout<<endl<<"ARCHIVO RECUPERADO...";
system("pause");
archivo_entrada.close();
}
void Lista::Recorrer(){
Nodo *aux=inicio;
while(aux){
cout<<"Nombre: "<<aux->Nombre<<endl;
aux=aux->siguiente;
}
system("pause");
}
int main(){
char dato[128];
Lista Nombres;
char opcion;
do{
system("cls");
cout<<"a) Insertar"<<endl;
cout<<"b) Recorrer"<<endl;
cout<<"c) Guardar"<<endl;
cout<<"d) Recuperar"<<endl;
cout<<"e) Salir"<<endl;
cout<<"QUE OPCION DESEA REALIZAR?"<<endl;
opcion= getche();
opcion= tolower(opcion);
switch(opcion){
case 'a':
system("cls");
cout<<"Nombre a insertar: ";
gets (dato);
Nombres.Insertar(dato);
break;
case 'b':

system("cls");
cout<<"Nombres de la lista "<<endl;
Nombres.Recorrer();
break;
case 'c':
Nombres.Guardar();
break;
case 'd':
Nombres.Recuperar();
break;
case 'e':
return 0;
default:
cout<<"OPCION NO VALIDA...";
system("pause");
break;
}
}while(1);
system("pause");
}

rbol binario
#include <iostream>
#include <stdlib.h>
#include<conio.h>
using namespace std;
/*--------- Estructura del arbol -------*/
typedef struct nodo{
int nro;
struct nodo *izq, *der;
}*ABB;
int numNodos = 0; // nummero de nodos del arbol ABB
int numK = 0, k;
// nodos menores que un numero k ingresado

/* ---------- Estructura de la cola ---------*/

struct nodoCola{
ABB ptr;
struct nodoCola *sgte;
};
struct cola{
struct nodoCola *delante;
struct nodoCola *atras;
};
void inicializaCola(struct cola &q)
{
q.delante = NULL;
q.atras = NULL;
}
void encola(struct cola &q, ABB n)
{
struct nodoCola *p;
p = new(struct nodoCola);
p->ptr = n;
p->sgte = NULL;
if(q.delante==NULL)
q.delante = p;
else
(q.atras)->sgte = p;
q.atras = p;
}
ABB desencola(struct cola &q)
{
struct nodoCola *p;
p = q.delante;
ABB n = p->ptr;
q.delante = (q.delante)->sgte;
delete(p);
return n;
}
ABB crearNodo(int x)
{
ABB nuevoNodo = new(struct nodo);
nuevoNodo->nro = x;
nuevoNodo->izq = NULL;
nuevoNodo->der = NULL;
return nuevoNodo;
}

void insertar(ABB &arbol, int x)

{
if(arbol==NULL)
{
system("cls");
arbol = crearNodo(x);
cout<<"\n\t Insertado..!"<<endl<<endl;
}
else if(x < arbol->nro)
insertar(arbol->izq, x);
else if(x > arbol->nro)
insertar(arbol->der, x);
}
void preOrden(ABB arbol)
{
if(arbol!=NULL)
{
cout << arbol->nro <<" ";
preOrden(arbol->izq);
preOrden(arbol->der);
}
}
void enOrden(ABB arbol)
{
if(arbol!=NULL)
{
enOrden(arbol->izq);
cout << arbol->nro << " ";
enOrden(arbol->der);
}
}
void postOrden(ABB arbol)
{
if(arbol!=NULL)
{
enOrden(arbol->izq);
enOrden(arbol->der);
cout << arbol->nro << " ";
}
}
void verArbol(ABB arbol, int n)
{
if(arbol==NULL)
return;
verArbol(arbol->der, n+1);

for(int i=0; i<n; i++)

cout<<" ";
numNodos++;
cout<< arbol->nro <<endl;
verArbol(arbol->izq, n+1);
}
bool busquedaRec(ABB arbol, int dato)
{
int r=0; // 0 indica que lo encontre
if(arbol==NULL)
return r;
if(dato<arbol->nro)
r = busquedaRec(arbol->izq, dato);
else if(dato> arbol->nro)
r = busquedaRec(arbol->der, dato);
else
r = 1; // son iguales, lo encontre
return r;
}
ABB unirABB(ABB izq, ABB der)
{
if(izq==NULL) return der;
if(der==NULL) return izq;
ABB centro = unirABB(izq->der, der->izq);
izq->der = centro;
der->izq = izq;
return der;
}
void elimina(ABB &arbol, int x)
{
if(arbol==NULL) return;
if(x<arbol->nro)
elimina(arbol->izq, x);
else if(x>arbol->nro)
elimina(arbol->der, x);
else
{

ABB p = arbol;
arbol = unirABB(arbol->izq, arbol->der);
delete p;
}
}
int alturaAB(ABB arbol)
{
int AltIzq, AltDer;
if(arbol==NULL)
return -1;
else
{
AltIzq = alturaAB(arbol->izq);
AltDer = alturaAB(arbol->der);
if(AltIzq>AltDer)
return AltIzq+1;
else
return AltDer+1;
}
}
void recorrerxNivel(ABB arbol)
{
struct cola q;
inicializaCola(q);
cout << "\t";
if(arbol!=NULL)
{
encola(q, arbol);
while(q.delante!=NULL)
{
arbol = desencola(q);
cout << arbol->nro << ' ';
if(arbol->izq!=NULL)
encola(q, arbol->izq);
if(arbol->der!=NULL)
encola(q, arbol->der);
}
}
}
ABB arbolEspejo(ABB arbol)
{
ABB temp;

if(arbol!=NULL)
{
temp = arbol->izq;
arbol->izq = arbolEspejo(arbol->der);
arbol->der = arbolEspejo(temp);
}
return arbol;
}
void nodosMenoresQueK(ABB arbol, int n)
{
if(arbol==NULL)
return;
nodosMenoresQueK(arbol->der, n+1);
if(arbol->nro<k)
numK++;
nodosMenoresQueK(arbol->izq, n+1);
}
int contarHojas(ABB arbol)
{
if (arbol==NULL)
{
return 0;
}
if ((arbol->der ==NULL)&&(arbol->izq ==NULL))
{
return 1;
}
else
{
return contarHojas(arbol->izq) + contarHojas(arbol->der);
}
}
void menu()
{
cout << "\t a... Insertar elemento..................\n";
cout << "\t b... Mostrar arbol......................\n";
cout << "\t c... Recorridos de profundiad...........\n";
cout << "\t d... Buscar elemento....................\n";
cout << "\t e... eliminar elemento..................\n";
cout << "\t f... recorrido por nieveles (Amplitud)..\n";
cout << "\t g... altura del arbol...................\n";
cout << "\t h... construir arbol reflejo............\n";
cout << "\t i... contar nodos.......................\n";
cout << "\t j.. nodos menores de 'k'...............\n";
cout << "\t k.. salir del programa.................\n";

cout << "\n\t Ingrese opcion : ";

}
void menu2()
{
cout << endl;
cout << "\t 1... inOrden
\n";
cout << "\t 2... PreOrden \n";
cout << "\t 3... PostOrden \n";
cout << "\n\t elije una opcion de las disponibles";
}
int main()
{
ABB arbol = NULL;
int x;
int op2;
char opcion;
do
{
system("cls");
menu(); opcion=getche();
opcion=tolower(opcion);
cout << endl;
switch(opcion)
{
case 'a':
system("cls");
cout << " ingresar el numero que quieres almacenar en el arbol
"; cin>> x;
insertar( arbol, x);
break;
case 'b':
system("cls");
system("cls");
verArbol(arbol, 0);
system("pause");
break;
case 'c':
system("cls");
menu2(); cin>> op2;
if(arbol!=NULL)
{
switch(op2)
{
case 1:

enOrden(arbol); break;
case 2:
preOrden(arbol); break;
case 3:
postOrden(arbol); break;
}
}
else
cout << "\n\t no puedo presentarte el orden ya que el arbol
esta vacio"<<endl;
break;
case 'd':
bool band;
system("cls");
cout<<" que valor deseas buscar "; cin>> x;
band = busquedaRec(arbol,x);
if(band==1)
cout << "\n\t el valor si se ha encontrado "<<endl;
else
cout << "\n\tel valor no se ha encontrado";
break;
case 'e':
system("cls");
cout<<" teclea el valor que desees qu se borre"; cin>> x;
elimina(arbol, x);
cout << "\n\t el valor se ha eliminado";
break;
case 'f':
system("cls");
cout<<"\n\n se mostrara el recorrido por amplitud\n\n";
recorrerxNivel(arbol);
break;
case 'g':
int h;
system("cls");
h = alturaAB(arbol);
cout << " la altura del arbol es de "<< h << endl;
break;
case 'h':
ABB espejo;
espejo = NULL;
system("cls");
cout << "\n\n arbol que ingresaste \n\n";

verArbol(arbol, 0);
cout << "\n\n arbol aplicando la funcion espejo \n\n";
espejo = arbolEspejo(arbol);
verArbol(espejo, 0);
break;
case 'i':
verArbol(arbol, 0);
system("cls");
cout << "\n\n numero de nodos"<<endl;
cout << numNodos;
break;
case 'j':
system("cls");
cout << " ingrese el valor de k para poder comparar "; cin>> k;
nodosMenoresQueK(arbol, 0);
cout <<" Son "<< numK << " numeros";
break;

case 'k':
return 0;
}
cout<<"\n\n\n";
}while(1);
}

rbol binario
#include<conio.h>
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<fstream>
#include<iostream>
#include<stdio.h>

using namespace std;

class ArbolABB {
private:
class Nodo {
public:
Nodo( int dat, Nodo *izq=NULL, Nodo *der=NULL) :
dato(dat), izquierdo(izq), derecho(der) {}
int dato;
Nodo *izquierdo;
Nodo *derecho;
};
Nodo *raiz;
Nodo *actual;
int contador;
int altura;
public:
ArbolABB() : raiz(NULL), actual(NULL) {}
~ArbolABB() { Podar(raiz); }
void Insertar(int dat);
void Borrar(int dat);
bool Buscar(int dat);
bool Vacio(Nodo *r) { return r==NULL; }
bool EsHoja(Nodo *r) { return !r->derecho && !r->izquierdo; }
const int NumeroNodos();
const int AlturaArbol();
int Altura(int dat);
int &ValorActual() { return actual->dato; }
void Raiz() { actual = raiz; }
void InOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PreOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PostOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
private:
void Podar(Nodo* &);
void auxContador(Nodo*);
void auxAltura(Nodo*, int);
};
void ArbolABB::Podar(Nodo* &nodo)
{
if(nodo) {
Podar(nodo->izquierdo);
Podar(nodo->derecho);
delete nodo;
nodo = NULL;
}
}

void ArbolABB::Insertar(int dat)

{
Nodo *padre = NULL;
actual = raiz;
while(!Vacio(actual) ) {
padre = actual;
if(dat > actual->dato) actual = actual->derecho;
else if(dat <= actual->dato) actual = actual->izquierdo;
}
if(Vacio(padre)) raiz = new Nodo(dat);
else if(dat <= padre->dato) padre->izquierdo = new Nodo(dat);
else if(dat > padre->dato) padre->derecho = new Nodo(dat);
}
void ArbolABB::Borrar(int dat)
{
Nodo *padre = NULL;
Nodo *nodo;
int aux;
actual = raiz;
while(!Vacio(actual)) {
if(dat == actual->dato) {
if(EsHoja(actual)) {
if(padre)
if(padre->derecho == actual) padre->derecho = NULL;
else if(padre->izquierdo == actual) padre->izquierdo = NULL;
delete actual;
actual = NULL;
return;
}
else {
padre = actual;
if(actual->derecho) {
nodo = actual->derecho;
while(nodo->izquierdo) {
padre = nodo;
nodo = nodo->izquierdo;
}
}
else {
nodo = actual->izquierdo;
while(nodo->derecho) {
padre = nodo;
nodo = nodo->derecho;
}
}

aux = actual->dato;
actual->dato = nodo->dato;
nodo->dato = aux;
actual = nodo;
}
}
else {
padre = actual;
if(dat > actual->dato) actual = actual->derecho;
else if(dat < actual->dato) actual = actual->izquierdo;
}
}
}
void ArbolABB::InOrden(void (*func)(int&), Nodo *nodo, bool r)
{
if(r) nodo = raiz;
if(nodo->izquierdo) InOrden(func, nodo->izquierdo, false);
func(nodo->dato);
if(nodo->derecho) InOrden(func, nodo->derecho, false);
}
void ArbolABB::PreOrden(void (*func)(int&), Nodo *nodo, bool r)
{
if(r) nodo = raiz;
func(nodo->dato);
if(nodo->izquierdo) PreOrden(func, nodo->izquierdo, false);
if(nodo->derecho) PreOrden(func, nodo->derecho, false);
}
void ArbolABB::PostOrden(void (*func)(int&), Nodo *nodo, bool r)
{
if(r) nodo = raiz;
if(nodo->izquierdo) PostOrden(func, nodo->izquierdo, false);
if(nodo->derecho) PostOrden(func, nodo->derecho, false);
func(nodo->dato);
}
bool ArbolABB::Buscar(int dat)
{
actual = raiz;
while(!Vacio(actual)) {
if(dat == actual->dato) return true;
else if(dat > actual->dato) actual = actual->derecho;
else if(dat < actual->dato) actual = actual->izquierdo;
}
return false;
}

int ArbolABB::Altura(int dat)

{
int altura = 0;
actual = raiz;
while(!Vacio(actual)) {
if(dat == actual->dato) return altura;
else {
altura++;
if(dat > actual->dato) actual = actual->derecho;
else if(dat < actual->dato) actual = actual->izquierdo;
}
}
return -1;
}
const int ArbolABB::NumeroNodos()
{
contador = 0;
auxContador(raiz); // FUncin auxiliar
return contador;
}
void ArbolABB::auxContador(Nodo *nodo)
{
contador++;
if(nodo->izquierdo) auxContador(nodo->izquierdo);
if(nodo->derecho) auxContador(nodo->derecho);
}
const int ArbolABB::AlturaArbol()
{
altura = 0;
auxAltura(raiz, 0);
return altura;
}

void ArbolABB::auxAltura(Nodo *nodo, int a)

{
if(nodo->izquierdo) auxAltura(nodo->izquierdo, a+1);
if(nodo->derecho) auxAltura(nodo->derecho, a+1);
if(EsHoja(nodo) && a > altura) altura = a;
}
void Mostrar(int &d)
{
cout << d << ",";

}
int main()
{
int dat;
char opcion;
ArbolABB A;
do{
system("cls");
cout<<"estructura de arbol"<<endl;
cout<<"a-) insertar un dato entero en el arbol "<<endl;
cout<<"b-) Borrar un dato del arbol"<<endl;
cout<<"c-) Busqueda"<<endl;
cout<<"d-) altura a la que se encuentra el nodo "<<endl;
cout<<"e-) InOrden"<<endl;
cout<<"f-) PreOrden"<<endl;
cout<<"g-) PostOrden"<<endl;
cout<<"h-) Altura del Arbol"<<endl;
cout<<"i-) salir del programa "<<endl;
cout<<"---------- elige una de las opciones "<<endl;
opcion=getche();
opcion=tolower(opcion);
switch(opcion){
case 'a':
cout<<"ingresa el numero entero a guardar"<<endl;
cin>>dat;
A.Insertar(dat);
cout<<endl<<"dato se ha insetado"<<endl;
system("pause");
break;
case 'b':
cout<<"ingrese el dato que desee borrar del arbol"<<endl;
cin>>dat;
A.Borrar(dat);
break;
case 'c':
cout<<"teclea el dato que deseas verificar su existencia"<<endl;
cin>>dat;
A.Buscar(dat);
if(A.Buscar(dat))
{
cout<<"el dato si existe en el arbol "<<endl;
system("pause");}
else
{
cout<<"el dato no existe en el arbol"<<endl;
system("pause");
}
system("pause");
break;
case 'd':

cout<<"ingrese el numero para verificar el nivel del nodo";

cin>>dat;
cout<<"el nivel del nodo tecleado es
"<<A.Altura(dat)<<endl;
system("pause");
break;
case 'e':
A.InOrden(Mostrar);
cout<<endl;
system("pause");
break;
case 'f':
A.PreOrden(Mostrar);
cout<<endl;
system("pause");
break;
case 'g':
A.PostOrden(Mostrar);
cout<<endl;
system("pause");
break;
case 'h':
cout<<"la altura es "<<A.AlturaArbol()<<endl;
system("pause");
break;
case 'i':
return 0;
break;
default:
cout<<endl<<" la opcion tecleada no es valida "<<endl;
system("pause");
}
}
while(1);
}