gonzalob

Untitled

Oct 21st, 2021
746
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef struct nodo
  5. {
  6.     struct nodo * siguiente;
  7.     int dato;
  8. }nodo;
  9.  
  10. typedef struct fila
  11. {
  12.     nodo * primero; //es la lista que conocemos;
  13.     nodo * ultimo; //es el ultimo;
  14.  
  15. }fila;
  16.  
  17. void inicFila(fila * unaFila);
  18. nodo * inicLista();
  19. void mostrarFila(fila * unaFila);
  20. void mostrarLista(nodo * lista);
  21. nodo * crearNodo(int dato);
  22. nodo * buscarUltimoLista(nodo * lista);
  23. nodo* agregarAlFinal(nodo* lista,nodo* nuevoNodo);
  24. void agregarFila(fila * unaFila, int dato);
  25. int extraer(fila * unaFila);
  26. nodo * borrarPrimero (nodo * lista);
  27. void vaciarFila(fila * unaFila);
  28.  
  29. int main()
  30. {
  31.     fila  unaFila;
  32.  
  33.     inicFila(&unaFila);
  34.  
  35.     int dato = -1;
  36.  
  37.     vaciarFila(&unaFila);
  38.  
  39.     agregarFila(&unaFila,10);
  40.  
  41.     agregarFila(&unaFila,5);
  42.  
  43.     agregarFila(&unaFila,15);
  44.  
  45.     mostrarFila(&unaFila);
  46.  
  47.     printf("\n");
  48.  
  49.     vaciarFila(&unaFila);
  50.  
  51.     /*
  52.  
  53.     dato = extraer(&unaFila);
  54.  
  55.       mostrarFila(&unaFila);
  56.  
  57.       printf("\n");
  58.  
  59.       dato = extraer(&unaFila);
  60.  
  61.         mostrarFila(&unaFila);
  62.  
  63.         printf("\n");
  64.  
  65.        dato = extraer(&unaFila);
  66.  
  67.           mostrarFila(&unaFila);
  68.  
  69.           printf("\n");.
  70.  
  71.           */
  72.  
  73.     return 0;
  74. }
  75.  
  76. void inicFila(fila * unaFila)
  77. {
  78.     unaFila->primero = inicLista();
  79.     unaFila->ultimo = inicLista();
  80. }
  81.  
  82. nodo * inicLista()
  83. {
  84.     return NULL;
  85. }
  86.  
  87. void mostrarFila(fila * unaFila)
  88. {
  89.     mostrarLista(unaFila->primero);
  90. }
  91.  
  92. void mostrarLista(nodo * lista)
  93. {
  94.     nodo * seg = lista;
  95.     while (seg)
  96.     {
  97.         printf("- %d -",seg->dato);
  98.         seg=seg->siguiente;
  99.     }
  100. }
  101.  
  102. nodo * crearNodo(int dato)
  103. {
  104.     nodo * nuevoNodo;
  105.     nuevoNodo = (nodo*)malloc(sizeof(nodo));
  106.     nuevoNodo->dato = dato;
  107.     nuevoNodo->siguiente = NULL;
  108.     return nuevoNodo;
  109. }
  110.  
  111. void agregarFila(fila * unaFila, int dato)
  112. {
  113.     nodo * nuevoNodo = crearNodo(dato);
  114.     if (unaFila->primero == NULL)
  115.     {
  116.         unaFila->primero = nuevoNodo;
  117.     }
  118.     else
  119.     {
  120.         unaFila->primero = agregarAlFinal(unaFila->primero,nuevoNodo);
  121.     }
  122.     unaFila->ultimo=nuevoNodo;
  123. }
  124.  
  125. nodo* agregarAlFinal(nodo* lista,nodo* nuevoNodo)
  126. {
  127.     nodo* seg=lista;
  128.     if(lista==NULL)
  129.     {
  130.         lista=nuevoNodo;
  131.     }
  132.     else
  133.     {
  134.         seg= buscarUltimoLista(lista);
  135.         seg->siguiente=nuevoNodo;
  136.     }
  137.     return lista;
  138. }
  139.  
  140. nodo * buscarUltimoLista(nodo * lista)
  141. {
  142.     nodo * ultimo;
  143.     if (lista == NULL)
  144.     {
  145.         ultimo = NULL;
  146.     }
  147.     else
  148.     {
  149.         nodo * seguidora = lista;
  150.         while (seguidora->siguiente !=NULL)
  151.         {
  152.             seguidora = seguidora->siguiente;
  153.         }
  154.         ultimo = seguidora;
  155.     }
  156.     return ultimo;
  157. }
  158.  
  159.  
  160. int extraer(fila * unaFila)
  161. {
  162.     int extraido = -1;
  163.  
  164.     if (unaFila->primero !=NULL)
  165.     {
  166.         extraido = unaFila->primero->dato; //copio el dato
  167.         //ahora a borrarlo
  168.         //borra y avanzo al segundo, ese segundo, lo actualizo
  169.         //en la variable primero
  170.         unaFila->primero = borrarPrimero(unaFila->primero);
  171.         if (unaFila->primero == NULL)
  172.         {
  173.             unaFila->ultimo = NULL;
  174.         }
  175.     }
  176.  
  177.     return extraido;
  178. }
  179.  
  180. nodo * borrarPrimero (nodo * lista)
  181. {
  182.     nodo * aBorrar = lista;
  183.     if (lista!=NULL)
  184.     {
  185.         lista = lista->siguiente;
  186.         free (aBorrar);
  187.     }
  188.     return lista;
  189. }
  190.  
  191. void vaciarFila(fila * unaFila)
  192. {
  193.     int borrado = 0;
  194.     if (unaFila->primero!=NULL)
  195.     {
  196.         printf("INICIO FILA\n");
  197.         while (unaFila->primero!=NULL)
  198.         {
  199.             borrado = extraer(unaFila);
  200.             printf("estoy borrando -> %d\n",borrado);
  201.         }
  202.         printf("FIN FILA\n");
  203.     }
  204.     else
  205.     {
  206.         printf("NO HAY FILA\n");
  207.     }
  208. }
  209.  
RAW Paste Data