Inicio » Escritorio » C / C++ » Listas en C++

Listas en C++

| 2013-04-27 | 20 Comments

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

enlace

Evolución de la lista

enlace2

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

enlace3

función borrar(elemento)

            buscar(elemento)

            si posic != inic

                        anterioràsiguiente = posicàsiguiente

            sino

                        inic = posic àsiguiente

            fin si

            liberar(posic)

fin función

enlace4

Ejemplo Lista Simplemente Enlazada

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
#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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
&nbsp;
 
//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;

Acerca del autor: Rodrigo Paszniuk

Ingeniero Informático, amante de la tecnología, la música, el ciclismo y aprender cosas nuevas.




SEGUÍNOS EN FACEBOOK

Los más vistos

GITHUB