Listas en C++

Listas – Definición

• Una lista lineal es un conjunto de elementos de un tipo dado que se encuentran ordenados y pueden variar en número.
• Permite el recorrido de todos y cada uno de sus elementos, sin saltear ninguno y en forma ordenada.
• Guía telefónica
• Lista de asistencia a un curso
• Índice de un libro
• Listado de compras
• Listado de ingredientes de una receta
• Etc.
  • Una lista enlazada o encadenada es un conjunto de elementos mas un campo especial que contiene el pun-tero al elemento siguiente de la lista.
  • Cada elemento de la lista debe tener al menos dos campos:
    • Elemento o dato.
    • Enlace, link, conexión al siguiente elemento.
  • Los elementos de una lista son enlazados por medio de los campos enlaces.

Ejemplos de Listas

Listas enlazadas

Operaciones básicas de la PILA

   Crear                         inicializar una lista vacía.

   Lista vacía    determinar si una lista esta vacía.

   Lista llena     determina si la lista se ha llenado.

   Insertar         inserta un elemento en la lista de forma que siga ordenada.

   Buscar           busca un determinado elemento dentro de la lista.

   Borrar           busca y elimina un elemento en la lista, manteniendo el orden.

Ejemplo de Nodo

Evolución de la lista

Implementación de las funciones con punteros

//Declaraciones generales

Estructura tipo_nombre

…………..

estructura tipo_nombre siguiente

Fin de estructura

tipo_nombre à inic, posic, anterior

función crear

            reservar (inic)

inicàsiguiente = nulo

inic àelemento = dato

posic = inic

fin función

lógica función vacía

            si inic = nulo

devolver(verdadero)

si_no

                        devolver(falso)

fin si

fin función

lógica función buscar (dato)

posic = inic

anterior = nulo

mientras (posicàsiguiente <> nulo y posic àelemento<dato)

                                   anterior = posic

posic = posic àsiguiente

fin mientras

            si (posic àelemento=dato)

                        retornar (verdadero)

            sino

                        retornar (falso)

            fin si

fin función

función insertar (datos)

            buscar (datos)

            reservar (elemento)

            elementoàdato=datos

            si posic != inic

                        anterioràsiguiente = elemento

                        elementoàsiguiente = posic

            sino

                        inic=elemento

                        elementoàsiguiente=posic

            fin si

fin función

función borrar(elemento)

            buscar(elemento)

            si posic != inic

                        anterioràsiguiente = posicàsiguiente

            sino

                        inic = posic àsiguiente

            fin si

            liberar(posic)

fin función

Ejemplo Lista Simplemente Enlazada

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <iostream.h>

struct dato {
 int i;
 dato *s;
 }*a, *i, *p, *e;

int da;

int buscar(int d);
void insertar(int dat);
void mostrar(void);
void borrar(void);
void menu(void);
void guardar(void);
void cargar(void);

main()
 {
 menu();
 }

void menu(void)
 {
 int opc,da;
 do
 {
 cout<<"1 - Buscar datos";
 cout<<"\t2 - Insertar datos";
 cout<<"\t3 - Mostrar todos los datos";
 cout<<"\t4 - Borrar un dato";
 cout<<"\t5 - Guardar datos a Archivo";
 cout<<"\t6 - Cargar datos de Archivo";
 cout<<"\t0 - Finalizar";
 cout<<"\nSeleccione opcion: ";
 cin>>opc;
 switch(opc)
 {
 case 0: cout<<"\n\nFinaliza el programa";
 getch();
 //no hay que olvidarse que antes de
 //abandonar el barco ...
 //hay que hundir todos los botes
 // o sea usar delete para eliminar
 //toda la lista
 p=i;
 while(p)
 {
 a=p;
 p=p->s;
 delete(a);
 }
 exit(0);
 case 1: cout<<"\n\nIngrese dato a buscar: ";
 cin>>da;
 if(buscar(da))
 cout<<"\n\nDato existe";
 else
 cout<<"\n\nDato NO EXISTE";
 getch();
 break;
 case 2: cout<<"Ingrese dato: ";
 cin>>da;
 insertar(da);
 break;
 case 3: mostrar();
 break;
 case 4: borrar();
 break;
 case 5: guardar();
 break;
 case 6: cargar();
 break;
 //por las dudas que el operador ingrese
 //cualquier verdura, fruta u otro tipo de hierba
 default: cout<<"\n\nOPCION NO VALIDA!!!";
 getch();
 }
 }while(opc);
 }

void mostrar(void)
 {
 int cont=1;
 if(!i)
 {
 cout<<"\n\nNO HAY LISTA PARA MOSTRAR";
 getch();
 return;
 }
 p=i;
 cout<<endl<<endl;
 while(p)
 {
 cout<<cont++<<" - Valor = "<<p->i<<endl;
 p=p->s;
 }
 cout<<"\n\nEso es todo";
 getch();
 }

int buscar(int d)
 {
 if (!i)
 {
 cout<<"No hay datos en la lista!!!";
 getch();
 return(0);
 }
 p=i;
 a=NULL;
 while(p->s && p->i<d)
 {
 a=p;
 p=p->s;
 }
 return(p->i==d?1:0);
 }

void insertar(int dat)
 {
 if(!i)
 {
 i=new(dato);
 i->s=NULL;
 i->i=dat;
 return;
 }
 if(buscar(dat))
 {
 cout<<"\n\nDato existente";
 getch();
 return;
 }
 e=new(dato);
 e->i=dat;
 if(p==i && p->s)
 {
 e->s=p;
 i=e;
 return;
 }
 if(p==i && !p->s)
 {
 if(p->i < e->i)
 {
 p->s=e;
 e->s=NULL;
 }
 else
 {
 e->s=p;
 i=e;
 }
 return;
 }
 if(p->s)
 {
 a->s=e;
 e->s=p;
 return;
 }
 if(e->i > p->i)
 {
 e->s=NULL;
 p->s=e;
 }
 else
 {
 a->s=e;
 e->s=p;
 }
 }

void borrar(void)
 {
 cout<<"\n\nIngrese dato a eliminar: ";
 cin>>da;
 if(buscar(da))
 {
 if(a)
 a->s=p->s;
 else
 i=p->s;
 delete(p);
 cout<<"\n\nDato eliminado";
 }
 else
 cout<<"\n\nDato no se encuentra";
 getch();
 }

void guardar(void)
 {
 FILE *arch;
 arch=fopen("DATOS-A.TXT","w");
 if(!i)
 {
 cout<<"\n\nNO HAY LISTA PARA GUARDAR";
 getch();
 return;
 }
 p=i;
 while(p)
 {
 fprintf(arch,"%i\n",p->i);
 p=p->s;
 }
 cout<<"\n\nArchivo Guardado";
 fclose(arch);
 getch();
 }

void cargar(void)
 {
 int c,x;
 FILE *arch;
 arch=fopen("DATOS-A.TXT","r");
 if(!arch)
 {
 cout<<"\n\nNO EXISTE EL ARCHIVO";
 getch();
 return;
 }

do {
 c=fscanf(arch,"%i\n",&x);
 if(c!=EOF)
 {
 insertar(x);
 }
 }
 while (c!=EOF);
 cout<<"\n\nArchivo Cargado";
 fclose(arch);
 getch();
 }

Ejemplo Lista Doblemente Enlazada

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>

struct direc
{
char nombre[30];
char calle[40];
char ciudad[20];
char estado[3];
char codigo[10];
struct direc *sig; //puntero a la siguiente entrada
struct direc *ante; //puntero al registro anterior
}entrada_lista;

struct direc *ppio; //puntero a la primera entrada de la lista
struct direc *final; //puntero a la ultima entrada de la lista
struct direc *buscar(char *); //puntero a una funcion

void intro(void),buscar(void),guardar(void);
void cargar(void),listar(void);
void borrar(struct direc **,struct direc **);
void dl_insert(struct direc *i,struct direc **ppio, struct direc **final);
void leecad(char *,char *,int),mostrar(struct direc *);
int menu (void);

main()
{
ppio=final=NULL; //inicializar los punteros
for(;;)
{
switch (menu())
{
case 1:intro();
break;
case 2:borrar(&ppio,&final);
break;
case 3:listar();
getch();
break;
case 4:buscar(); //encuentra un nombre
getch();
break;
case 5:guardar(); //guarda la lista en un disco
break;
case 6:cargar(); //lee del disco
break;
case 7:exit(0); //fin de programa
}
}
}

//seleccionar una operacion
int menu(void)
{
char s[80];
int c;
printf("\n1. introducir un nombre\n");
printf("2. borrar un nombre\n");
printf("3. listar el archivo\n");
printf("4. buscar\n");
printf("5. guardar el archivo\n");
printf("6. cargar el archivo\n");
printf("7. salir\n");
do
{
printf("\nintroduzca su opcion: ");
gets(s);
c=atoi(s);
}while(c<0 || c>7);
return(c);
}

//introducir nombres y direcciones
void intro(void)
{
struct direc *info;
for (;;)
{
info=(struct direc *)malloc (sizeof(entrada_lista)); //new(entrada_lista)
if (!info)
{
printf("\nno hay memoria");
return;
}
leecad("introduzca nombre: ",info->nombre,30);
if (!info->nombre[0])break; //terminar
leecad("introduzca calle: ",info->calle,40);
leecad("introduzca ciudad: ",info->ciudad,20);
leecad("introduzca provincia: ",info->estado,3);
leecad("introduzca codigo: ",info->codigo,10);
dl_insert(info,&ppio,&final);
} //bucle de entrada
}

//esta funcion lee una cadena de longitud maxima cont.
//previene el desbordamiento de la cadena y visualiza un mensaje indicativo

void leecad(char *indic,char *s,int cont)
{
char p[255];
do
{
printf(indic);
gets(p);
if (strlen(p)>cont)
{
printf("\ndemasiado largo\n");
printf("La longitud permitida es %i\n",cont);
}
}while(strlen(p)>cont);
strcpy(s,p);
}

//crea una lista doblemente enlazada ordenadamente

void dl_insert(
struct direc *i, //nuevo elemento
struct direc **ppio, //primer elemento de la lista
struct direc **final //ultimo elemento de la lista
)
{
struct direc *ant,*p;
if (*final==NULL) //primer elemento de la lista
{
i->sig=NULL;
i->ante=NULL;
*final=i;
*ppio=i;
return;
}

p=*ppio; //principio de la lista
ant=NULL;
while (p)
{
if(strcmp(p->nombre,i->nombre)<=0)
{
ant=p;
p=p->sig;
}
else
{
if(p->ante)
{
p->ante=i;
i->sig=p;
i->ante=ant; //p->ante;
ant->sig=i; //p->ante=i;
return;
}
i->sig=p; //nuevo primer elemento
i->ante=NULL;
p->ante=i;
*ppio=i;
return;
}
}
ant->sig=i; //ponerlo en el final
i->sig=NULL;
i->ante=ant;
*final=i;
}

//elimina un elemento de la lista
void borrar(struct direc **ppio, struct direc **final)
{
struct direc *info, *buscar(char *nombre);
char s[80];

printf("introduzca nombre: ");
gets(s);
info=buscar(s);
if(info)
{
if(*ppio==info)
{
*ppio=info->sig;
if (*ppio)
(*ppio)->ante=NULL;
else
*final=NULL;
}
else
{
info->ante->sig=info->sig;
if (info!=*final)
info->sig->ante= info->ante;
else
*final=info->ante;
}
free(info); //devolver memoria al sistema
}
}

//buscar una direccion
struct direc *buscar(char *nombre)
{
struct direc *info;
info=ppio;
while(info)
{
if(!strcmp(nombre,info->nombre))
return info;
info=info->sig; //obtener siguiente direccion
}
printf("nombre no encontrado\n");
return NULL; //no encontrado
}

//mostrar la lista entera
void listar(void)
{
struct direc *info;

info=ppio;
if (!info)
{
printf("\n Lista Vacía\n");
return;
}
while(info)
{
mostrar(info);
info=info->sig; //obtener siguiente direccion
}
printf("\n Fin de Lista\n");
}

//esta funcion imprime realmente los campos de cada direccion
void mostrar(struct direc *info)
{
printf("%s ",info->nombre);
printf("%s ",info->calle);
printf("%s ",info->ciudad);
printf("%s ",info->estado);
printf("%s \n",info->codigo);
}

//buscar un nombre en la lista
void buscar(void)
{
char nombre[40];
struct direc *info, *buscar(char *nombre);

printf("introduzca nombre: ");
gets(nombre);
info=buscar(nombre);
if (!info)
printf("no encontrado\n");
else
mostrar(info);
}

//guardar el archivo en disco
void guardar(void)
{
struct direc *info;
FILE *fp;

fp=fopen("listac","wb");
if (!fp)
{
printf("no se puede abrir el archivo\n");
exit(1);
}
printf("\nguardando el archivo");

info=ppio;
while(info)
{
fwrite(info,sizeof(struct direc),1,fp);
info=info->sig; //obtiene la siguiente direccion
}
fclose(fp);
}

//cargar el archivo de direcciones
void cargar()
{
struct direc *info;
FILE *fp;

fp=fopen("listac","rb");
if (!fp)
{
printf("no se puede abrir el archivo\n");
exit(1);
}
//liberar cualquier memoria previamente dispuesta
while (ppio)
{
info=ppio->sig;
free(info);
ppio=info;
}
//reinicializar los punteros
ppio=final=NULL;

printf("\ncargando el archivo\n");
while(!feof(fp))
{
info=(struct direc *)malloc(sizeof(struct direc));
if (!info)
{
printf("no hay memoria");
return;
}
if (1!=fread(info, sizeof(struct direc), 1,fp)) break;
dl_insert(info,&ppio,&final);
}
fclose(fp);
}

 Ejemplo de Lista enlazada circular

 

//LISTA DOBLE CIRCULARES
 #include<iostream.h>
 #include<conio.h>
 #include<stdio.h>
 #include<stdlib.h>

//Estructuras Doblemente enlazadas
 typedef struct nododoble
 {
 int dato;
 struct nodoc *sig;
 struct nodoc *ant;

}tipoNodo;

//PROTOTIPOS
 tipoNodo *nuevo_elemento();
 void crearc();
 void presentar();
 void presentar_recorrido();
 void insertar();
 void insertarfinalc();
 void insertarordenadoc();
 void insertarinicioc();
 void modificar();
 void buscar();
 void ordenar();
 void ordenarc();
 void ordenarcdesc();
 void eliminar();
 void eliminar_cabeza();
 void cuadro(int x1,int y1,int x2,int y2,char c);

tipoNodo *cab;
 tipoNodo *cola;

tipoNodo *nuevo_elemento()
 {
 tipoNodo *nodo1;
 nodo1=(tipoNodo *)malloc(sizeof(tipoNodo ));
 if(!nodo1)
 cout<<”No se ha reservado memoria para el nuevo “;
 return nodo1;
 }

//MENU PRINCIPAL
 void main()
 {
 clrscr();
 creardoble();
 clrscr();
 char opc=’ ‘;

do
 {

clrscr();
 cuadro(1,10,35,56,’’);
 gotoxy(13,3);cout<<”->[ LISTAS ENLAZADAS CIRCULARES ]<-\n”;
 gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
 gotoxy(12,9); cout<<” [1]: INSERTAR \n”;
 gotoxy(12,12);cout<<” [2]: MODIFICAR\n”;
 gotoxy(12,15);cout<<” [3]: BUSCAR\n”;
 gotoxy(12,18);cout<<” [4]: ORDENAR\n”;
 gotoxy(12,21);cout<<” [5]: ELIMINAR\n”;
 gotoxy(12,24);cout<<” [6]: PRESENTAR\n”;
 gotoxy(12,27);cout<<” [7]: PRESENTAR RECORRIDO\n”;
 gotoxy(12,30);cout<<” [8]: SALIR DEL MENU\n”;
 gotoxy(12,33);cout<<” Elegir una Opci¢n [ ]“;
 gotoxy(32,33);cin>>opc;

switch(opc)
 {
 case’1':
 clrscr();
 insertar();;getch();break;
 case’2':
 clrscr();
 modificar();getch();break;
 case’3':
 clrscr();
 buscar();getch();break;
 case’4':
 clrscr();
 ordenar();getch();break;
 case’5':
 clrscr();
 eliminar();getch();break;

case’6':
 clrscr();
 presentar();getch();break;
 case’7':
 clrscr();
 presentar_recorrido();getch();break;
 }

}while(opc!=’8');

getch();

}

//CREAR LA CABEZA
 void crearc()
 {
 clrscr();
 int dat;
 gotoxy(20,20);
 cout<<”Ingrese Elemento: “;
 cin>>dat;
 cab=nuevo_elemento();
 cab->dato=dat;
 cola=cab;
 cola->sig=cab;
 cab->ant=cola;
 getch();
 }

void insertar()
 {
 clrscr();
 char opc=’ ‘;

do
 {

clrscr();
 cuadro(1,10,25,56,’’);
 gotoxy(13,3);cout<<”->[ INSERTAR ELEMENMTOS A LA LISTA ENLAZADA ]<-\n”;
 gotoxy(12,6); cout<<” [1]: INSERTAR ORDENADO\n”;
 gotoxy(12,9);cout<<” [2]: INSERTAR CABEZA\n”;
 gotoxy(12,12);cout<<” [3]: INSERTAR AL FINAL\n”;
 gotoxy(12,15);cout<<” [4]: REGRESAR\n”;
 gotoxy(12,17);cout<<” Elegir una Opci¢n [ ]“;
 gotoxy(32,17);cin>>opc;
 switch(opc)
 {
 case’1':
 clrscr();
 insertarordenadoc();getch();break;

case’2':
 clrscr();

insertarinicioc();getch();break;

case’3':
 clrscr();
 insertarfinalc();getch();break;
 }

}
 while(opc!=’4');

getch();

}

void insertarfinalc()
 {
 clrscr();
 nodoc *elem;
 elem=nuevo_elemento();
 clrscr();
 gotoxy(20,20);
 cout<<”\t\t”<<”INGRESE VALOR :\t”;
 cin>>elem->dato;
 cola->sig=elem;
 elem->ant=cola;
 elem->sig=cab;
 cab->ant=elem;
 cola=elem;
 getch();

}

void insertarordenadoc()
 {
 nodoc *ant;
 nodoc *Aux;
 nodoc *post;
 int dat;
 Aux=nuevo_elemento();
 ant=nuevo_elemento();
 post=nuevo_elemento();
 gotoxy(18,22);
 cout<<”Ingrese un elemento: “;
 cin>>dat;
 Aux->dato=dat;
 if(Aux->dato>cab->dato)
 {
 ant=cab;
 post=cab->sig;
 while((Aux->dato>post->dato)&&(post->sig!=cab))
 {
 ant=post;
 post=post->sig;
 }
 if(post->sig==cab)
 {
 if (Aux->dato<post->dato)
 {
 Aux->sig=post;
 post->ant=Aux;
 ant->sig=Aux;
 Aux->ant=ant;
 }
 else
 {
 Aux->sig=cab;
 post->sig=Aux;
 Aux->ant=post;
 cab->ant=Aux;
 cola=Aux;
 }
 }
 else
 {
 Aux->sig=post;
 post->ant=Aux;
 ant->sig=Aux;
 Aux->ant=ant;
 }
 }
 else
 {
 Aux->dato=dat;
 Aux->sig=cab;
 cab->ant=Aux;
 Aux->ant=cola;
 cab=Aux;
 cola->sig=cab;
 }
 }
 void insertarinicioc()
 {
 nodoc *Aux;
 int dat;
 Aux=nuevo_elemento();
 gotoxy(18,22);
 cout<<”Ingrese un numero:”;
 cin>>dat;
 Aux->dato=dat;
 Aux->sig=cab;
 cab->ant=Aux;
 cola->sig=Aux;
 Aux->ant=cola;
 cab=Aux;
 getch();
 }

void modificar()
 {
 clrscr();
 nodoc *modificar;
 nodoc *ele;
 modificar=nuevo_elemento();
 int db,encontrado=0;
 modificar=cab;
 gotoxy(10,20);
 cout<<”\t”<<”INGRESE EL VALOR A MODIFICAR :\t”;
 cin>> db;
 for(int c=0;c<=1;c++)
 {

while(db!=modificar->dato)
 {
 modificar=modificar->sig;

}
 gotoxy(10,22);
 cout<<”Elemento existente en la lista”;
 encontrado=1;
 gotoxy(10,25);
 cout<<”\t\t”<<”INGRESE VALOR :\t”;
 cin>>ele->dato;
 modificar->dato=ele->dato;

c++;
 }
 if(encontrado==0)
 {
 gotoxy(10,22);
 cout<<”Elemento no existente en la lista”;
 }

getch();
 }
 void buscar()
 {
 clrscr();
 cuadro(15,5,50,25,’');
 nodoc *buscar;
 buscar=nuevo_elemento();
 int db,encontrado=0;
 buscar=cab;
 gotoxy(18,15);
 cout<<”Ingrese el numero a buscar: “;
 cin>> db;

for(int c=0;c<=1;c++)
 {
 while(buscar->dato!=db)
 {

buscar=buscar->sig;
 }

gotoxy(18,18);
 cout<<”Elemento existente en la lista”;
 encontrado=1;

c++;
 }
 if(encontrado==0)
 {
 gotoxy(18,18);cout<<”Elemento no existente en la lista”;
 }
 getch();
 }

void ordenar()
 {
 clrscr();
 char opc=’ ‘;

do
 {

clrscr();
 cuadro(1,10,25,56,’’);
 gotoxy(13,3);cout<<”->[ ORDENAR LAS LISTAS ENLAZADAS ]<-\n”;
 gotoxy(12,6);cout<<” MENU PRINCIPAL\n”;
 gotoxy(12,9); cout<<” [1]: ORDENAR ASCENDENTE\n”;
 gotoxy(12,12);cout<<” [2]: ORDENAR DESCENDENTE\n”;
 gotoxy(12,15);cout<<” [3]: REGRESAR\n”;

gotoxy(12,17);cout<<” Elegir una Opci¢n [ ]“;
 gotoxy(32,17);cin>>opc;
 switch(opc)
 {
 case’1':
 clrscr();
 ordenarc();break;
 case’2':
 clrscr();
 ordenarcdesc();break;

}

}
 while(opc!=’3');

getch();

}
 void ordenarc()
 {
 nodoc *aux;
 nodoc *temp;
 int vaux;
 aux=nuevo_elemento();
 temp=nuevo_elemento();
 aux=cab;
 while (aux->sig!=cab)
 {
 temp=aux;
 while(temp->sig!=cab)
 {
 temp=temp->sig;
 if(aux->dato>temp->dato)
 {
 vaux=aux->dato;
 aux->dato=temp->dato;
 temp->dato=vaux;
 }
 }
 aux=aux->sig;
 }
 }
 void ordenarcdesc()
 {
 nodoc *aux;
 nodoc *temp;
 int vaux;
 aux=nuevo_elemento();
 temp=nuevo_elemento();
 aux=cab;
 while (aux->sig!=cab)
 {
 temp=aux;
 while(temp->sig!=cab)
 {
 temp=temp->sig;
 if(aux->dato<temp->dato)
 {
 vaux=aux->dato;
 aux->dato=temp->dato;
 temp->dato=vaux;
 }
 }
 aux=aux->sig;
 }
 }

void presentar()
 {
 clrscr();
 nodoc * recorre;
 recorre=nuevo_elemento();
 recorre=cab;
 cout<<”Elementos insertados:\n\n”;
 for(int c=0;c<=1;c++)
 {
 cout<<recorre->dato<<”\t”;
 recorre=recorre->sig;
 while(recorre!=cab)
 {
 cout<<recorre->dato<<”\t”;
 recorre=recorre->sig;
 }
 c++;
 }

getch();
 }
 void presentar_recorrido()
 {
 clrscr();
 nodoc * recorre;
 recorre=nuevo_elemento();
 recorre=cab;
 cout<<”Elementos insertados:\n\n”;
 for(int c=0;c<=1;c++)
 {
 cout<<recorre->dato<<”\t”;
 recorre=recorre->sig;
 while(recorre!=cab)
 {
 cout<<recorre->dato<<”\t”;
 recorre=recorre->sig;
 }
 cout<<”\n”;
 }

getch();

}

void eliminar()
 {
 presentar();
 nodoc *eliminar;
 nodoc *asigna;
 gotoxy(10,25);cout<<”ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
 gotoxy(10,26);cout<<”º º\n”;
 gotoxy(10,27);cout<<”ºINSERTAR NUMERO A ELIMINARº\n”;
 gotoxy(10,28);cout<<”º º\n”;
 gotoxy(10,29);cout<<”ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;
 gotoxy(10,31);cout<<”Ingrese el n—mero a eliminar\t”;
 cin>>eliminar->dato;
 if (eliminar->dato==cab->dato)
 {

eliminar_cabeza();
 }

else
 {
 nodoc *anterior=cab;
 nodoc * aux=cab->sig;

while((aux!=NULL)&&(aux->dato!=eliminar->dato))
 {
 anterior=aux;
 aux=aux->sig;
 }
 if(aux!=NULL)
 {
 asigna=aux->sig;
 anterior->sig=asigna;
 aux->ant=anterior;
 aux->ant=NULL;
 aux->sig=NULL;
 free(aux);
 }
 else
 {
 gotoxy(10,33);
 cout<<”NO SE ENCUENTRA”;
 }
 }

}

void eliminar_cabeza()
 {
 /* nododoble *aux;
 aux=cab;
 cab=cab->sig;
 // cab->ant=cola;
 aux->sig=NULL;
 cab->ant=cola;
 aux->ant=NULL;
 free(aux); */
 nodoc *aux;
 aux=cab;
 cab=cab->sig;
 // aux->sig=NULL;
 aux->ant=NULL;
 free(aux);

}

void cuadro(int x1,int y1, int x2, int y2, char simb)
 {
 for (int i1=y1;i1<=y2;i1++)
 {
 gotoxy(i1,x1);cout<<simb;
 gotoxy(i1,x2);cout<<simb;
 }
 for (int i2=x1;i2<=x2;i2++)
 {
 gotoxy(y1,i2);cout<<simb;
 gotoxy(y2,i2);cout<<simb;
 }
 }

&nbsp;