Advertisement
gonzalob

Untitled

Sep 7th, 2021
889
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 3.64 KB | None | 0 0
  1. #include "listas_dobles.h"
  2.  
  3. nodoDoble * inicListaDoble()
  4. {
  5.     return NULL;
  6. }
  7.  
  8. nodoDoble * crearNodoDoble(empleado unEmpleado)
  9. {
  10.     nodoDoble * nuevoNodoDoble = (nodoDoble *)malloc(sizeof(nodoDoble));
  11.  
  12.     nuevoNodoDoble->anterior = NULL;
  13.     nuevoNodoDoble->siguiente = NULL;
  14.  
  15.     nuevoNodoDoble->unEmpleado = unEmpleado;
  16.  
  17.     return nuevoNodoDoble;
  18. }
  19.  
  20. nodoDoble * cargarNodoDoble()
  21. {
  22.     empleado unEmpleado;
  23.  
  24.     printf("Ingrese el nombre del empleado\n");
  25.     fflush(stdin);
  26.     scanf("%s",&unEmpleado.NyA);
  27.  
  28.     printf("Ingrese el sueldo del empleado\n");
  29.     fflush(stdin);
  30.     scanf("%f",&unEmpleado.sueldo);
  31.  
  32.     nodoDoble * nuevoNodoDoble = crearNodoDoble(unEmpleado);
  33.     return nuevoNodoDoble;
  34. }
  35.  
  36. void mostrarEmpleado(empleado unEmpleado)
  37. {
  38.     printf("Sueldo del empleado -> %f\n",unEmpleado.sueldo);
  39.     printf("Nombre del empleado -> %s\n",unEmpleado.NyA);
  40.     printf("*********************\n");
  41. }
  42.  
  43. nodoDoble *agregarAlPpioNodoDoble( nodoDoble * listaDoble, nodoDoble * nuevoNodoDoble)
  44. {
  45.     if (listaDoble == NULL)
  46.     {
  47.         listaDoble = nuevoNodoDoble;
  48.     }
  49.     else
  50.     {
  51.         listaDoble->anterior = nuevoNodoDoble; //viejo primero apunta ahora al nuevo primero
  52.         nuevoNodoDoble->siguiente = listaDoble; //nuevo primero apunta ahora al nuevo segundo
  53.         listaDoble = nuevoNodoDoble;
  54.     }
  55.  
  56.     return listaDoble;
  57. }
  58.  
  59. nodoDoble *agregarAlPpio2NodoDoble( nodoDoble * listaDoble, nodoDoble * nuevoNodoDoble)
  60. {
  61.     nuevoNodoDoble->siguiente = listaDoble; //puede ser o no null pero no nos importa xq? xq no accedemos a un atributo
  62.     if (listaDoble!=NULL)
  63.     {
  64.         listaDoble->anterior = nuevoNodoDoble;
  65.     }
  66.     return nuevoNodoDoble;
  67. }
  68.  
  69. void mostrarListaDoble(nodoDoble * listaDoble)
  70. {
  71.     nodoDoble * seguidora = listaDoble;
  72.     while (seguidora!=NULL)
  73.     {
  74.         mostrarEmpleado(seguidora->unEmpleado);
  75.         seguidora = seguidora->siguiente;
  76.     }
  77. }
  78.  
  79. void mostrarListaDobleFin(nodoDoble * listaDoble)
  80. {
  81.     nodoDoble * ultimo = buscarUltimoListaDoble(listaDoble);
  82.     if (ultimo!=NULL)
  83.     {
  84.         while (ultimo!=NULL)
  85.         {
  86.             mostrarEmpleado(seguidora->unEmpleado);
  87.             ultimo = ultimo->anterior;
  88.         }
  89.     }
  90. }
  91.  
  92. nodoDoble * buscarUltimoListaDoble(nodoDoble * listaDoble)
  93. {
  94.     nodoDoble * seguidora = listaDoble;
  95.     if (seguidora!=NULL)
  96.     {
  97.         while (seguidora->siguiente!=NULL)
  98.         {
  99.             seguidora = seguidora->siguiente;
  100.         }
  101.     }
  102.     return seguidora;
  103.  
  104. }
  105.  
  106. nodoDoble * agregarListaDobleEnOrden(nodoDoble * listaDoble, nodoDoble * nuevoNodo)
  107. {
  108.     if (listaDoble == NULL)
  109.     {
  110.         listaDoble = nuevoNodo;
  111.     }
  112.     else if (nuevoNodo->unEmpleado.sueldo < listaDoble->unEmpleado.sueldo)
  113.     {
  114.         listaDoble = agregarAlPpioNodoDoble(listaDoble,nuevoNodo);
  115.     }
  116.     else
  117.     {
  118.         nodoDoble * seguidora = listaDoble;
  119.         while ((seguidora!=NULL) && (nuevoNodo->unEmpleado.sueldo > seguidora->unEmpleado.sueldo))
  120.         {
  121.             seguidora= seguidora->siguiente;
  122.         }
  123.  
  124.         nuevoNodo->siguiente = seguidora;
  125.         if (seguidora!=NULL)
  126.         {
  127.             nuevoNodo->anterior = seguidora->anterior;
  128.             nodoDoble * anterior = seguidora->anterior;
  129.             anterior->siguiente = nuevoNodo;
  130.             seguidora->anterior = nuevoNodo;
  131.  
  132.         }
  133.         else
  134.         {
  135.             nodoDoble * ultimo = buscarUltimoListaDoble(listaDoble);
  136.             nuevoNodo->anterior = ultimo;
  137.             ultimo->siguiente = nuevoNodo;
  138.  
  139.         }
  140.  
  141.  
  142.         //seguidora->anterior->siguiente puede ser que C no lo tome
  143.     }
  144.  
  145.     return listaDoble;
  146. }
  147.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement