elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  [C] (Aporte) Estructura de pila y cola con memoria dinámica
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [C] (Aporte) Estructura de pila y cola con memoria dinámica  (Leído 3,166 veces)
class_OpenGL


Desconectado Desconectado

Mensajes: 437

Si usas Direct3D, no eres mi amigo :P


Ver Perfil
[C] (Aporte) Estructura de pila y cola con memoria dinámica
« en: 22 Agosto 2016, 21:01 pm »

Hola, muy buenas. Dado un tema reciente decidí implementar en C una estructura que funcione como cola y otra como pila (estructuras FIFO y LIFO respectivamente). Bueno, parece que son muchas líneas, pero entre comentarios, y saltos de líneas "innecesarios", el código no es tan largo. Aquí se los dejo.

NOTA: Ya sé que ya se ha subido la implementación de estas estructuras, pero eso fue en C++, no en C.

Código
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3.  
  4. // Para generalizar, uso un tipo de datos predefinido, así puedo
  5. // cambiar entre int y el tipo de datos que quiera
  6. typedef int tipo;
  7.  
  8. typedef struct ElementoLista{
  9. tipo dato;
  10. struct ElementoLista *siguiente;
  11. } Elemento;
  12.  
  13. // En la estructura de una pila, solo necesitamos la referencia al
  14. // último elemento agregado
  15. typedef struct {
  16. Elemento *ultimo;
  17. unsigned int num_elementos;
  18. } Pila;
  19.  
  20. // Pero en la estructura de una cola, también necesitaremos la
  21. // referencia del primer elemento
  22. typedef struct {
  23. Elemento *primero;
  24. Elemento *ultimo;
  25. unsigned int num_elementos;
  26. } Cola;
  27.  
  28. // Si alguna de estas dos funciones retorna 0, significa que
  29. // ha ocurrido un error, de lo contrario, retornará un valor
  30. // diferente de 0
  31. int agregar_a_pila(Pila *pila, tipo dato);
  32. int agregar_a_cola(Cola *cola, tipo dato);
  33.  
  34. // Destruye el último elemento y retorna los datos almacenados en el
  35. tipo quitar_a_pila(Pila *pila);
  36. tipo quitar_a_cola(Cola *cola);
  37.  
  38. // Para demostrar el uso de 'quitar_a_pila' y 'quitar_a_cola'
  39. // estas funciones destruyen la pila y la cola respectivamente
  40. // al mostrarlas
  41. void mostrar_pila(Pila *pila);
  42. void mostrar_cola(Cola *cola);
  43.  
  44. int main() {
  45. // No hay que olvidarse de inicializar, porque si no,
  46. // no hay manera de determinar si un puntero a memoria
  47. // dinámica es válido o no...
  48. Pila pila = {NULL, 0};
  49. Cola cola = {NULL, NULL, 0};
  50. tipo dato;
  51.  
  52. // Para probar que todo funciona perfectamente, hacemos que el
  53. // usuario introduzca enteros para almacenarlos tanto en una cola
  54. // como en una pila.
  55. fprintf(stdout, "Introduzca una serie de numeros (0 para acabar): ");
  56. fscanf(stdin, "%d", &dato);
  57. while(0 != dato) {
  58. agregar_a_pila(&pila, dato);
  59. agregar_a_cola(&cola, dato);
  60. fscanf(stdin, "%d", &dato);
  61. }
  62.  
  63. // Mostramos la pila y la cola (destruyendo a su vez los datos
  64. // de las mismas)
  65. mostrar_pila(&pila);
  66. fputc('\n', stdout);
  67. mostrar_cola(&cola);
  68.  
  69. return 0;
  70. }
  71.  
  72. int agregar_a_pila(Pila *pila, tipo dato) {
  73. Elemento *elemento;
  74.  
  75. // Creamos elemento y guardamos datos...
  76. elemento = malloc(sizeof(Elemento));
  77. if(NULL == elemento)
  78. return 0;
  79.  
  80. elemento->dato = dato;
  81.  
  82. // Reconfiguramos pila...
  83. if(NULL == pila->ultimo) {
  84. elemento->siguiente = NULL;
  85. pila->num_elementos = 1;
  86. pila->ultimo = elemento;
  87. } else {
  88. elemento->siguiente = pila->ultimo;
  89. pila->num_elementos += 1;
  90. pila->ultimo = elemento;
  91. }
  92.  
  93. return 1;
  94. }
  95.  
  96. int agregar_a_cola(Cola *cola, tipo dato) {
  97. Elemento *elemento;
  98.  
  99. // Creamos elemento y guardamos datos...
  100. elemento = malloc(sizeof(Elemento));
  101. if(NULL == elemento)
  102. return 0;
  103.  
  104. elemento->dato = dato;
  105. elemento->siguiente = NULL;
  106.  
  107. // Reconfiguramos cola...
  108. if(NULL == cola->primero) {
  109. cola->num_elementos = 1;
  110. cola->primero = elemento;
  111. cola->ultimo = elemento;
  112. } else {
  113. cola->ultimo->siguiente = elemento;
  114. cola->num_elementos += 1;
  115. cola->ultimo = elemento;
  116. }
  117.  
  118. return 1;
  119. }
  120.  
  121. tipo quitar_a_pila(Pila *pila) {
  122. Elemento *temp;
  123. tipo dato;
  124.  
  125. if(NULL != pila->ultimo) {
  126. dato = pila->ultimo->dato;
  127. temp = pila->ultimo;
  128. pila->ultimo = pila->ultimo->siguiente;
  129. pila->num_elementos -= 1;
  130. free(temp);
  131. } else {
  132. dato = -1;
  133. }
  134.  
  135. return dato;
  136. }
  137.  
  138. tipo quitar_a_cola(Cola *cola) {
  139. Elemento *temp;
  140. tipo dato;
  141.  
  142. // Hacemos esta asignación, porque si el primer elemento de la cola y
  143. // el último son iguales, destruiremos el primer elemento, dejando al último
  144. // sin memoria asignada, por lo que directamente al último elemento le
  145. // asignamos NULL para que no haya errores
  146. if(cola->primero == cola->ultimo)
  147. cola->ultimo = NULL;
  148.  
  149. if(NULL != cola->primero) {
  150. dato = cola->primero->dato;
  151. temp = cola->primero;
  152. cola->primero = cola->primero->siguiente;
  153. cola->num_elementos -= 1;
  154. free(temp);
  155. } else {
  156. dato = -1;
  157. }
  158.  
  159. return dato;
  160. }
  161.  
  162. void mostrar_pila(Pila *pila) {
  163. tipo dato;
  164.  
  165. while(NULL != pila->ultimo) {
  166. dato = quitar_a_pila(pila);
  167. fprintf(stdout, "%d ", dato);
  168. }
  169. }
  170.  
  171. void mostrar_cola(Cola *cola) {
  172. tipo dato;
  173.  
  174. while(NULL != cola->primero) {
  175. dato = quitar_a_cola(cola);
  176. fprintf(stdout, "%d ", dato);
  177. }
  178. }


En línea

Programador aficionado. Me quiero centrar en programar videojuegos. La API que uso para crearlos es OpenGL
AlbertoBSD
Programador y
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.605


🏴 Libertad!!!!!


Ver Perfil WWW
Re: [C] (Aporte) Estructura de pila y cola con memoria dinámica
« Respuesta #1 en: 23 Agosto 2016, 00:58 am »

 ;-) ;-) ;-)

Y con tipos de datos Genericos!!!

Código
  1. // cambiar entre int y el tipo de datos que quiera
  2. typedef int tipo;

Podrían ocultar ahi una estructura incluso hasta apuntadores  :silbar: :silbar:

Saludo!


En línea

Donaciones
1Coffee1jV4gB5gaXfHgSHDz9xx9QSECVW
class_OpenGL


Desconectado Desconectado

Mensajes: 437

Si usas Direct3D, no eres mi amigo :P


Ver Perfil
Re: [C] (Aporte) Estructura de pila y cola con memoria dinámica
« Respuesta #2 en: 23 Agosto 2016, 04:56 am »

¡Claro! Podrías poner un puntero void * que guarde datos genéricos, e incluso hacer que la función haga una copia de esos datos para que así hacer que el que programa no tenga que preocuparse por liberar o no la memoria almacenada en la pila!
En línea

Programador aficionado. Me quiero centrar en programar videojuegos. La API que uso para crearlos es OpenGL
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines