LISTAS, PILAS Y COLAS C++

LISTAS, PILAS Y COLAS   C++

Revisando por ahí unas cosas viejas del disco encontré un par de ejemplitos que hice y que me resultaron muy útiles en aquella época en la que cursaba Programación en la universidad. Teniendo en cuenta que el desarrollo de estas estructuras de datos con punteros resulta a veces un poco complicada, me parece interesante exponer a continuación un par de programitas extremadamente sencillos que ilustran como se puede trabajar para lidiar con estas cosas. Los programas creo que resultan claros en sí mismos, por lo que no le agregué comentarios... son libres de consultarme ante cualquier duda.

Cola

En este .cpp se pide el ingreso por teclado de un conjunto de datos de manera iterativa hasta que se ingrese la palabra "fin" cuando la consola pida el dato "Nombre". Una vez finalizado el ingreso, y si hay datos en la cola, se procede a mostrarlos navegando mediante las estructuras (struct). Cada estructura contiene la posición de memoria de la estructura siguiente en la cola, por lo que se las recorrerá hasta el final y se las irá eliminando de la memoria (ya que conceptualmente un nodo debe leerse de memoria una única vez).

cola.cpp

PLAIN TEXT

C:

1. #include
2. #include
3. #include
4. #include
5.  
6. struct agenda
7. {
8.     char nombre[50];
9.     char telefono[25];
10.     char mail[50];
11. };
12.  
13. struct nodo
14. {
15.     struct agenda dato;
16.     struct nodo *proximo;
17. };
18.  
19. struct nodo *nuevonodo();
20. int colavacia(struct nodo *);
21. struct nodo *creacola(struct nodo *, struct agenda);
22. void mostrar(struct nodo *);
23.  
24. void main()
25. {
26.     struct nodo *pri=NULL, *ult=NULL;
27.     struct agenda x;
28.     printf("Ingrese nombre: ");
29.     gets(x.nombre);
30.     while(strcmpi(x.nombre,"fin"))
31.     {
32.         printf("Ingrese telefono: ");
33.         gets(x.telefono);
34.         printf("Ingrese mail: ");
35.         gets(x.mail);
36.         ult=creacola(ult,x);
37.         if(pri==NULL) pri=ult; // Si es la 1º pasada pongo en pri el valor del primer nodo
38.         printf("Ingrese nombre: ");
39.         gets(x.nombre);
40.     }
41.     if(colavacia(pri)==1) { printf("No se ingresaron registros"); getch(); }
42.     else mostrar(pri);
43. }
44.  
45. struct nodo *nuevonodo()
46. {
47.     struct nodo *p;
48.     p=(struct nodo *)malloc(sizeof(struct nodo));
49.     if(p==NULL)
50.     {
51.         printf("Memoria RAM Llena");
52.         getch();
53.         exit(0);
54.     }
55.     return p;
56. }
57.  
58. struct nodo *creacola(struct nodo *ult, struct agenda x)
59. {
60.     struct nodo *p;
61.     p=nuevonodo();
62.     (*p).dato=x;
63.     (*p).proximo=NULL;
64.     if(ult!=NULL) (*ult).proximo=p; // Si hay nodo anterior en prox pongo la direccion del nodo actual
65.     return p;
66. }
67.  
68. int colavacia(struct nodo *pri)
69. {
70.     if(pri==NULL) return 1;
71.     else return 0;
72. }
73.  
74. void mostrar(struct nodo *pri)
75. {
76.     struct nodo *aux;
77.     while(pri!=NULL)
78.     {
79.         printf("Nombre: %s - Telefono: %s - Mail: %s \n",pri->dato.nombre,pri->dato.telefono,pri->dato.mail);
80.         aux=pri;
81.         pri=(*pri).proximo;
82.         free(aux);
83.     }
84.     getch();
85. }

Pila

En este caso también se solicita un conjunto de datos de manera iterativa a ingresar por teclado. Cuando se finaliza el ingreso, se porcede a mostrar los elementos de la pila y además se utiliza un archivo binario para transformar la pila en memoria en una estructura de datos persistente. Cada nodo de la pila, como en el caso anterior, mantendrá una referencia al nodo siguiente haciendo posible el futuro recorrido de la misma. Luego de finalizada la muestra de los elementos de la pila, se consulta al usuario si se desea acceder a los datos de la misma almacenados en el archivo binario, para lo cual, en el caso de responder Si (S), se accede al archivo y se imprimen los registros de manera secuencial.

...