Pilas Y Colas

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

C:

1. #include <stdio.h>

2. #include <conio.h>

3. #include <stdlib.h>

4. #include <string.h>

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);

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.

C:

1. #include <conio.h>

2. #include <stdio.h>

3. #include <stdlib.h>

4. #include <ctype.h>

5.

6. struct productos

7. {

8. int codigo;

9. char nombre[50];

10. int existencia;

11. float precio;

12. };

13.

14. struct nodo

15. {

16. struct productos dato;

17. struct nodo *proximo;

18. };

19.

20. /* Declaracion de funciones */

21. void archivo(FILE *fp);

22. struct nodo *nuevonodo();

23. struct nodo *creapila(struct nodo *pri, struct productos x);

24. void muestra(struct nodo *pri, FILE *fp);

25. /* Fin de Declaracion */

26.

27. void main()

28. {

29. struct productos x;

30. struct nodo *pri=NULL;

31. FILE *fp;

32. char opcion; float auxiliar=0;

33. if((fp=fopen("C:\\Datos.txt","wb"))==NULL)

34. {

35. getch();

36. }

37. fseek(fp,0,2);

38. do

39. {

40. fflush(stdin);

41. printf("Ingrese el Codigo de Producto ");

42. scanf("%d",&x.codigo);

43. fflush(stdin);

44. printf("Ingrese Nombre de Producto ");

45. gets(x.nombre);

46. fflush(stdin);

47. printf("Ingrese la Existencia ");

48. scanf("%d",&x.existencia);

49. fflush(stdin);

50. printf("Ingrese el Precio ");

51. scanf("%f",&auxiliar); x.precio=auxiliar;

52. pri=creapila(pri,x);

53. fflush(stdin);

54. printf("Desea Ingresar otro Registro? (S/N) ");

55. scanf("%c",&opcion); opcion=toupper(opcion);

56. } while(opcion=='S');

57. muestra(pri,fp);

58. fflush(stdin);

59. printf("El contenido de la Pila se ha Guardado. Desea Visualizarlo? (S/N)");

60. scanf("%c",&opcion); opcion=toupper(opcion);

61. if(opcion=='S') archivo(fp);

62. getch();

63. fclose(fp);

64. }

65.

66. struct nodo *creapila(struct nodo *pri, struct productos x)

67. {

68. struct nodo *p;

69. p=nuevonodo();

70. (*p).dato=x;

71. (*p).proximo=pri;

72. return p;

73. }

74.

75. struct nodo *nuevonodo()

76. {

77. struct nodo *p;

78. p=(struct nodo *)malloc(sizeof(struct nodo));

79. if(p==NULL)

80. {

81. printf("Memoria RAM Llena");

82. getch();

83. exit(0);

84. }

85. return p;

86. }

87.

88. void muestra(struct nodo *pri, FILE *fp)

89. {

90. clrscr();

91. struct nodo *aux;

92. while(pri!=NULL)

93. {

94. printf("Codigo: %d \n",(*pri).dato.codigo);

95. printf("Nombre: %s \n",(*pri).dato.nombre);

96. printf("Existencia: %d \n",(*pri).dato.existencia);

97. printf("Precio: %0.2f \n\n",(*pri).dato.precio);

98. fwrite(&pri->dato,sizeof(struct productos),1,fp);

99. aux=pri;

100. pri=(*pri).proximo;

101. free(aux);

102. }

103. }

104.

105. void archivo(FILE *fp)

106. {

107. struct productos x;

108. clrscr();

109. printf("Datos del Archivo:\n\n");

110. fread(&x,sizeof(struct productos),1,fp);

111. while(!feof(fp))

112. {

113. printf("Codigo: %d \n",x.codigo);

114. printf("Nombre: %s \n",x.nombre);

115. printf("Existencia: %d \n",x.existencia);

116. printf("Precio: %0.2f \n\n",x.precio);

117. fread(&x,sizeof(struct productos),1,fp);

118. }

119. printf("Fin de Archivo");

120. }

Una cola es un tipo especial de lista abierta en la que sólo se pueden insertar nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el otro. Además, como sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído. Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir.

El símil cotidiano es una cola para comprar, por ejemplo, las entradas del cine. Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.

El nodo típico para construir pilas es el mismo que vimos en los capítulos anteriores para la construcción de listas y pilas:

struct nodo {

int dato;

struct nodo *siguiente;

Los tipos que definiremos normalmente para manejar colas serán casi los mismos que para manejar listas y pilas, tan sólo cambiaremos algunos nombres:

typedef struct

...