API tools faq
paste
Advertisement
tomasfdel

Estructuras I Práctica 2

tomasfdel
Apr 19th, 2017
430
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.36 KB | None | 0 0
raw download clone embed print report
  1. /// EJERCICIO 2
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include "slist.h"
  6.  
  7. ///Solo hice el test de las últimas 3, las otras doy por sentado que funcan.
  8.  
  9. static void imprimir_entero(int dato) {
  10.   printf("%d ", dato);
  11. }
  12.  
  13. int mayor (int a, int b){
  14.     return a>b;}
  15.  
  16.  
  17. SList slist_crear() {
  18.   return NULL;
  19. }
  20.  
  21. void slist_destruir(SList lista) {
  22.   SNodo *nodoAEliminar;
  23.   while (lista != NULL) {
  24.     nodoAEliminar = lista;
  25.     lista = lista->sig;
  26.     free(nodoAEliminar);
  27.   }
  28. }
  29.  
  30. int slist_vacia(SList lista) {
  31.   return lista == NULL;
  32. }
  33.  
  34. SList slist_agregar_final(SList lista, int dato) {
  35.   SNodo *nuevoNodo = malloc(sizeof(SNodo));
  36.   nuevoNodo->dato = dato;
  37.   nuevoNodo->sig = NULL;
  38.  
  39.   if (lista == NULL)
  40.     return nuevoNodo;
  41.  
  42.   SList nodo = lista;
  43.   for (;nodo->sig != NULL;nodo = nodo->sig);
  44.   /* ahora 'nodo' apunta al ultimo elemento en la lista */
  45.  
  46.   nodo->sig = nuevoNodo;
  47.   return lista;
  48. }
  49.  
  50. SList slist_agregar_inicio(SList lista, int dato) {
  51.   SNodo *nuevoNodo = malloc(sizeof(SNodo));
  52.   nuevoNodo->dato = dato;
  53.   nuevoNodo->sig = lista;
  54.   return nuevoNodo;
  55. }
  56.  
  57. void slist_recorrer(SList lista, FuncionVisitante visit) {
  58.   for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  59.     visit(nodo->dato);
  60. }
  61.  
  62. int slist_longitud (SList lista){
  63.     int contador = 0;
  64.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  65.         contador++;
  66.     return contador;
  67.     }
  68.  
  69. SList slist_concatenar (SList lista1, SList lista2) {
  70.     for (; lista2 != NULL; lista2 = lista2->sig)
  71.         lista1 = slist_agregar_final(lista1, lista2->dato);
  72.     return lista1;
  73.     }
  74.  
  75. SList slist_insertar (SList lista, int dato, int posicion){
  76.     if(slist_longitud(lista) < posicion || posicion < 0)
  77.         return lista;
  78.     if (lista == NULL)
  79.         return slist_agregar_inicio(lista, dato);
  80.  
  81.     int bandera = 1;
  82.     SList backup = lista;
  83.  
  84.     for (;bandera<posicion; bandera++ , lista = lista->sig);
  85.  
  86.     SNodo *nuevoNodo = malloc(sizeof(SNodo));
  87.     nuevoNodo->dato = dato;
  88.     nuevoNodo->sig = lista->sig;
  89.  
  90.     lista->sig = nuevoNodo;
  91.  
  92.     return backup;
  93.     }
  94.  
  95. SList slist_eliminar(SList lista, int posicion) {
  96.     if (lista == NULL || slist_longitud(lista) < posicion || posicion < 0)
  97.         return lista;
  98.     SNodo* pepe;
  99.     if (posicion == 0){
  100.         pepe = lista;
  101.         lista = lista->sig;
  102.         free(pepe);
  103.         return lista;
  104.     }
  105.     int indice = 1;
  106.     SList back = lista;
  107.     for (; indice < posicion; indice++, lista = lista->sig);
  108.     pepe = lista->sig;
  109.     lista->sig = lista->sig->sig;
  110.     free(pepe);
  111.     return back;
  112. }
  113.  
  114. int slist_contiene(SList lista, int dato) {
  115.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  116.         if (nodo->dato == dato) return 1;
  117.  
  118.     return 0;
  119. }
  120.  
  121. int slist_indice (SList lista, int dato) {
  122.     for (int indice = 0; lista != NULL; lista = lista->sig, indice++)
  123.         if (lista->dato == dato)
  124.             return indice;
  125.     return -1;
  126.    }
  127.  
  128. SList slist_intersecar (SList lista1, SList lista2) {
  129.     SList nuevo = slist_crear();
  130.  
  131.     if(lista1 == NULL || lista2 == NULL)
  132.         return nuevo;
  133.  
  134.     for(;lista1 != NULL;lista1 = lista1->sig)
  135.         if(! (slist_contiene(nuevo, lista1->dato)) && slist_contiene(lista2, lista1->dato))
  136.             nuevo = slist_agregar_final(nuevo, lista1->dato);
  137.  
  138.     return nuevo;
  139. }
  140.  
  141. int slist_contiene_custom (SList lista, int dato, int (*comparador) (int, int)) {
  142.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  143.         if (comparador(nodo->dato, dato))  return 1;
  144.  
  145.     return 0;
  146. }
  147.  
  148. SList slist_intersecar_custom (SList lista1, SList lista2, int (*comparador) (int, int)) {
  149.     SList nuevo = slist_crear();
  150.  
  151.     if(lista1 == NULL || lista2 == NULL)
  152.         return nuevo;
  153.  
  154.     for(;lista1 != NULL;lista1 = lista1->sig)
  155.         if (! (slist_contiene(nuevo, lista1->dato)) && slist_contiene_custom(lista2, lista1->dato, comparador))
  156.             nuevo = slist_agregar_final (nuevo, lista1->dato);
  157.  
  158.     return nuevo;
  159. }
  160.  
  161. void slist_ordenar (SList lista, int (*comparador) (int, int)){
  162.     int largo = slist_longitud(lista), aux;
  163.     SList puntero;
  164.     for(int i=largo-1; i>0; i--){
  165.         puntero=lista;
  166.         for(int j=0; j<i; puntero = puntero->sig, j++)
  167.             if(comparador(puntero->dato, puntero->sig->dato)){
  168.                 aux = puntero->dato;
  169.                 puntero->dato = puntero->sig->dato;
  170.                 puntero->sig->dato = aux;
  171.             }
  172.     }
  173. }
  174.  
  175. SList slist_reverso (SList lista) {
  176.     SList nuevo = slist_crear();
  177.     for(;lista != NULL;lista = lista->sig)
  178.         nuevo = slist_agregar_inicio(nuevo, lista->dato);
  179.  
  180.     return nuevo;
  181. }
  182.  
  183. SList slist_intercalar (SList lista1, SList lista2){
  184.     int oscilador = 0;
  185.     SList nueva = slist_crear();
  186.     for(;lista1 != NULL && lista2!= NULL; oscilador++){
  187.         if(oscilador % 2){
  188.             nueva = slist_agregar_final(nueva, lista2->dato);
  189.             lista2 = lista2->sig;
  190.         }
  191.         else{
  192.             nueva = slist_agregar_final(nueva, lista1->dato);
  193.             lista1 = lista1->sig;
  194.             }
  195.     }
  196.     for(;lista1 != NULL; lista1 = lista1->sig)
  197.         nueva = slist_agregar_final(nueva, lista1->dato);
  198.  
  199.     for(;lista2 != NULL; lista2 = lista2->sig)
  200.         nueva = slist_agregar_final(nueva, lista2->dato);
  201.  
  202.     return nueva;
  203. }
  204.  
  205.  
  206. int main(int argc, char *argv[]) {
  207.  
  208.   SList lista = slist_crear(), reversa;
  209.  
  210.   lista = slist_agregar_inicio(lista, 17);
  211.   lista = slist_agregar_inicio(lista, -2);
  212.   lista = slist_agregar_inicio(lista, 4);
  213.   lista = slist_agregar_final(lista, 3);
  214.  
  215.   slist_recorrer(lista, imprimir_entero);
  216.   printf("\n");
  217.  
  218.   slist_ordenar(lista, mayor);
  219.   slist_recorrer(lista, imprimir_entero);
  220.   printf("\n");
  221.   reversa = slist_reverso(lista);
  222.   slist_recorrer(reversa, imprimir_entero);
  223.   printf("\n");printf("\n");
  224.  
  225.   lista = slist_agregar_final(lista, 69);
  226.   lista = slist_agregar_final(lista, 74);
  227.   lista = slist_agregar_final(lista, 7);
  228.   slist_recorrer(lista, imprimir_entero);
  229.   printf("\n");
  230.   slist_recorrer(reversa, imprimir_entero);
  231.   printf("\n");
  232.  
  233.   lista = slist_intercalar(lista, reversa);
  234.   slist_recorrer(lista, imprimir_entero);
  235.   printf("\n");
  236.  
  237.  
  238.   slist_destruir(lista);
  239.   slist_destruir(reversa);
  240.   return 0;
  241. }
  242.  
  243.  
  244.  
  245. ///EJERCICIO 6
  246.  
  247.  
  248.  
  249. #include <stdio.h>
  250. #include <stdlib.h>
  251. #include <stdint.h>
  252.  
  253.  
  254. typedef struct _lista{
  255.     int dato;
  256.     uintptr_t puntero;
  257.     }DNodo;
  258. typedef DNodo *DList;
  259.  
  260.  
  261.  
  262. void mostrar (DList lista){
  263.     DList anterior = NULL, auxiliar = lista;
  264.     for(;lista!=NULL;lista = lista->puntero ^ (uintptr_t) anterior, anterior = auxiliar, auxiliar = lista)
  265.         printf("%d ",lista->dato);
  266.  
  267.     printf("\n\n");
  268.     }
  269.  
  270.  
  271. DList agregar_final(DList lista, int dato) {
  272.     DList nuevoNodo = (DList) malloc(sizeof(DNodo));
  273.     nuevoNodo->dato = dato;
  274.  
  275.     if (lista == NULL){
  276.         nuevoNodo -> puntero = 0;
  277.         return nuevoNodo;
  278. }
  279.  
  280.     DList nodo = lista, anterior = NULL, auxiliar = lista;
  281.     for (;nodo != NULL; nodo = nodo->puntero ^ (uintptr_t)anterior, anterior = auxiliar, auxiliar = nodo);
  282.     anterior -> puntero = anterior->puntero ^ (uintptr_t)nuevoNodo;
  283.     nuevoNodo -> puntero = (uintptr_t) anterior ^ 0;
  284.     return lista;
  285. }
  286.  
  287.  
  288.  
  289. DList agregar_inicio(DList lista, int dato) {
  290.  
  291.   DList nuevoNodo = (DList) malloc(sizeof(DNodo));
  292.   nuevoNodo->dato = dato;
  293.     if(lista == NULL)
  294.         nuevoNodo->puntero = 0;
  295.     else{
  296.         nuevoNodo->puntero = (uintptr_t)lista;
  297.         lista->puntero = (uintptr_t) lista->puntero ^ (uintptr_t) nuevoNodo;
  298.     }
  299.   return nuevoNodo;
  300. }
  301.  
  302.  
  303.  
  304. int main() {
  305.     DList inicio = NULL;
  306.     printf("Anduvo\n");
  307.     inicio = agregar_inicio(inicio, 3);
  308.     mostrar(inicio);
  309.     inicio = agregar_inicio(inicio, 2);
  310.     mostrar(inicio);
  311.     inicio = agregar_inicio(inicio, 1);
  312.     mostrar(inicio);
  313.     printf("Anduvo\n");
  314.     inicio = agregar_final(inicio, 4);
  315.     inicio = agregar_final(inicio, 5);
  316.     mostrar(inicio);
  317.     return 0;
  318. }
  319.  
  320.  
  321.  
  322.  
  323.  
  324. ///EJERCICIO 9
  325.  
  326.  
  327. #include <stdio.h>
  328. #include <stdlib.h>
  329. #include <string.h>
  330. #include "slist.h"
  331. #define CANT_COMANDOS 14
  332.  
  333. typedef struct Lista{
  334.     char nombre[15];
  335.     SList nodos;
  336. }Lista;
  337.  
  338.  
  339. char *lista_comandos[CANT_COMANDOS];
  340. Lista ** Matriz = NULL;
  341. int cantidad_listas = 0;
  342.  
  343.  
  344. static void imprimir_entero(int dato) {
  345.   printf("%d ", dato);
  346. }
  347.  
  348. int mayor (int a, int b){
  349.     return a>b;}
  350.  
  351.  
  352. SList slist_crear() {
  353.   return NULL;
  354. }
  355.  
  356. void slist_destruir(SList lista) {
  357.   SNodo *nodoAEliminar;
  358.   while (lista != NULL) {
  359.     nodoAEliminar = lista;
  360.     lista = lista->sig;
  361.     free(nodoAEliminar);
  362.   }
  363. }
  364.  
  365. int slist_vacia(SList lista) {
  366.   return lista == NULL;
  367. }
  368.  
  369. SList slist_agregar_final(SList lista, int dato) {
  370.   SNodo *nuevoNodo = (SNodo *) malloc(sizeof(SNodo));
  371.   nuevoNodo->dato = dato;
  372.   nuevoNodo->sig = NULL;
  373.  
  374.   if (lista == NULL)
  375.     return nuevoNodo;
  376.  
  377.   SList nodo = lista;
  378.   for (;nodo->sig != NULL;nodo = nodo->sig);
  379.   /* ahora 'nodo' apunta al ultimo elemento en la lista */
  380.  
  381.   nodo->sig = nuevoNodo;
  382.   return lista;
  383. }
  384.  
  385. SList slist_agregar_inicio(SList lista, int dato) {
  386.   SNodo *nuevoNodo = (SNodo *) malloc(sizeof(SNodo));
  387.   nuevoNodo->dato = dato;
  388.   nuevoNodo->sig = lista;
  389.   return nuevoNodo;
  390. }
  391.  
  392. void slist_recorrer(SList lista, FuncionVisitante visit) {
  393.   for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  394.     visit(nodo->dato);
  395. }
  396.  
  397. int slist_longitud (SList lista){
  398.     int contador = 0;
  399.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  400.         contador++;
  401.     return contador;
  402.     }
  403.  
  404. SList slist_concatenar (SList lista1, SList lista2) {
  405.     for (; lista2 != NULL; lista2 = lista2->sig)
  406.         lista1 = slist_agregar_final(lista1, lista2->dato);
  407.     return lista1;
  408.     }
  409.  
  410. SList slist_insertar (SList lista, int dato, int posicion){
  411.     if(slist_longitud(lista) < posicion || posicion < 0)
  412.         return lista;
  413.     if (lista == NULL)
  414.         return slist_agregar_inicio(lista, dato);
  415.  
  416.     int bandera = 1;
  417.     SList backup = lista;
  418.  
  419.     for (;bandera<posicion; bandera++ , lista = lista->sig);
  420.  
  421.     SNodo *nuevoNodo = (SNodo *) malloc(sizeof(SNodo));
  422.     nuevoNodo->dato = dato;
  423.     nuevoNodo->sig = lista->sig;
  424.  
  425.     lista->sig = nuevoNodo;
  426.  
  427.     return backup;
  428.     }
  429.  
  430. SList slist_eliminar(SList lista, int posicion) {
  431.     if (lista == NULL || slist_longitud(lista) < posicion || posicion < 0)
  432.         return lista;
  433.     SNodo* pepe;
  434.     if (posicion == 0){
  435.         pepe = lista;
  436.         lista = lista->sig;
  437.         free(pepe);
  438.         return lista;
  439.     }
  440.     int indice = 1;
  441.     SList back = lista;
  442.     for (; indice < posicion; indice++, lista = lista->sig);
  443.     pepe = lista->sig;
  444.     lista->sig = lista->sig->sig;
  445.     free(pepe);
  446.     return back;
  447. }
  448.  
  449. int slist_contiene(SList lista, int dato) {
  450.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  451.         if (nodo->dato == dato) return 1;
  452.  
  453.     return 0;
  454. }
  455.  
  456. void slist_indice (SList lista, int dato) {
  457.     int flag = 0;
  458.     for (int indice = 0; lista != NULL; lista = lista->sig, indice++)
  459.         if (lista->dato == dato){
  460.             printf("%d ",indice);
  461.             flag = 1;
  462.     }
  463.    
  464.     if (flag)
  465.         printf("\n");
  466.     else
  467.         printf("El elemento buscado no existe en la lista.\n");
  468.    
  469.    }
  470.  
  471. SList slist_intersecar (SList lista1, SList lista2) {
  472.     SList nuevo = slist_crear();
  473.  
  474.     if(lista1 == NULL || lista2 == NULL)
  475.         return nuevo;
  476.  
  477.     for(;lista1 != NULL;lista1 = lista1->sig)
  478.         if(! (slist_contiene(nuevo, lista1->dato)) && slist_contiene(lista2, lista1->dato))
  479.             nuevo = slist_agregar_final(nuevo, lista1->dato);
  480.  
  481.     return nuevo;
  482. }
  483.  
  484. int slist_contiene_custom (SList lista, int dato, int (*comparador) (int, int)) {
  485.     for (SNodo *nodo = lista; nodo != NULL; nodo = nodo->sig)
  486.         if (comparador(nodo->dato, dato))  return 1;
  487.  
  488.     return 0;
  489. }
  490.  
  491. SList slist_intersecar_custom (SList lista1, SList lista2, int (*comparador) (int, int)) {
  492.     SList nuevo = slist_crear();
  493.  
  494.     if(lista1 == NULL || lista2 == NULL)
  495.         return nuevo;
  496.  
  497.     for(;lista1 != NULL;lista1 = lista1->sig)
  498.         if (! (slist_contiene(nuevo, lista1->dato)) && slist_contiene_custom(lista2, lista1->dato, comparador))
  499.             nuevo = slist_agregar_final (nuevo, lista1->dato);
  500.  
  501.     return nuevo;
  502. }
  503.  
  504. void slist_ordenar (SList lista, int (*comparador) (int, int)){
  505.     int largo = slist_longitud(lista), aux;
  506.     SList puntero;
  507.     for(int i=largo-1; i>0; i--){
  508.         puntero=lista;
  509.         for(int j=0; j<i; puntero = puntero->sig, j++)
  510.             if(comparador(puntero->dato, puntero->sig->dato)){
  511.                 aux = puntero->dato;
  512.                 puntero->dato = puntero->sig->dato;
  513.                 puntero->sig->dato = aux;
  514.             }
  515.     }
  516. }
  517.  
  518. SList slist_reverso (SList lista) {
  519.     SList nuevo = slist_crear();
  520.     for(;lista != NULL;lista = lista->sig)
  521.         nuevo = slist_agregar_inicio(nuevo, lista->dato);
  522.  
  523.     return nuevo;
  524. }
  525.  
  526. SList slist_intercalar (SList lista1, SList lista2){
  527.     int oscilador = 0;
  528.     SList nueva = slist_crear();
  529.     for(;lista1 != NULL && lista2!= NULL; oscilador++){
  530.         if(oscilador % 2){
  531.             nueva = slist_agregar_final(nueva, lista2->dato);
  532.             lista2 = lista2->sig;
  533.         }
  534.         else{
  535.             nueva = slist_agregar_final(nueva, lista1->dato);
  536.             lista1 = lista1->sig;
  537.             }
  538.     }
  539.     for(;lista1 != NULL; lista1 = lista1->sig)
  540.         nueva = slist_agregar_final(nueva, lista1->dato);
  541.  
  542.     for(;lista2 != NULL; lista2 = lista2->sig)
  543.         nueva = slist_agregar_final(nueva, lista2->dato);
  544.  
  545.     return nueva;
  546. }
  547.  
  548. int char_a_int (char * cadena){
  549.     int resultado=0, i=0;
  550.  
  551.     if(cadena[0]=='-') i++;
  552.  
  553.     for(; cadena[i]!='\0';i++){
  554.         resultado*=10;
  555.         resultado += (cadena[i] - '0');
  556.         }
  557.  
  558.     if(cadena[0] == '-')
  559.         return -1 * resultado;
  560.  
  561.     return resultado;
  562. }
  563.  
  564.  
  565.  
  566. void inicializar_comandos(){
  567.     lista_comandos[0]="salir";
  568.     lista_comandos[1]="crear";
  569.     lista_comandos[2]="destruir";
  570.     lista_comandos[3]="imprimir";
  571.     lista_comandos[4]="agregar_final";
  572.     lista_comandos[5]="agregar_inicio";
  573.     lista_comandos[6]="agregar_pos";
  574.     lista_comandos[7]="longitud";
  575.     lista_comandos[8]="concatenar";
  576.     lista_comandos[9]="eliminar";
  577.     lista_comandos[10]="contiene";
  578.     lista_comandos[11]="indice";
  579.     lista_comandos[12]="intersecar";
  580.     lista_comandos[13]="ordenar";
  581.     }
  582.  
  583.  
  584. void copiar_nombre (char * buffer, char * nombre, int inicio){
  585.     int i;
  586.     for(i=0; buffer[i+inicio]!=' ' && buffer[i+inicio] != '\0'; i++)
  587.         nombre[i] = buffer[i+inicio];
  588.  
  589.     nombre[i] = '\0';
  590.     }
  591.  
  592.  
  593.  int existe_lista (char * nombre){
  594.     int i;
  595.     for(i=0; i < cantidad_listas; i++)
  596.         if(!strcmp(nombre, Matriz[i]->nombre))
  597.             return i;
  598.  
  599.      return -1;
  600.      }
  601.  
  602.  
  603. void ingresar_comando (char * buffer){
  604.     int i=0;
  605.     char caracter;
  606.     while((caracter=getchar()) != '\n')
  607.         buffer[i++] = caracter;
  608.     buffer[i]= '\0';
  609. }
  610.  
  611. int leer_comando (char * buffer){
  612.     int i=0, j=0, flag=0;
  613.     for(i=0;i<CANT_COMANDOS;i++){
  614.         flag=1;
  615.         for(j=0;lista_comandos[i][j]!='\0';j++)
  616.             if(buffer[j]!=lista_comandos[i][j]){
  617.                 flag = 0;
  618.                 break;}
  619.  
  620.         if(flag) return i;
  621.     }
  622.     return -1;}
  623.  
  624.  
  625. int interpretar_comando (char * buffer){
  626.     int resultado = leer_comando(buffer), existe, existe2, existe3, flag;
  627.     char posible_nombre[15], posible_nombre2[15], posible_nombre3[15], posible_numero[15], posible_posicion[15];
  628.     int dato, posicion;
  629.     switch(resultado){
  630.         case 0:
  631.             printf("Bye bye! \n");
  632.            
  633.             break;
  634.            
  635.            
  636.         case 1:
  637.             copiar_nombre(buffer, posible_nombre, 6);
  638.             existe = existe_lista(posible_nombre);
  639.  
  640.             if(existe != -1)
  641.                 return -1;
  642.  
  643.             cantidad_listas++;
  644.             Matriz = (Lista **) realloc (Matriz, (sizeof(Lista *) * cantidad_listas));
  645.             Matriz[cantidad_listas-1] = (Lista *) malloc (sizeof(Lista));
  646.             strcpy(Matriz[cantidad_listas-1]->nombre,posible_nombre);
  647.             Matriz[cantidad_listas-1]->nodos = slist_crear();
  648.  
  649.             break;
  650.  
  651.  
  652.  
  653.         case 2:
  654.             copiar_nombre(buffer, posible_nombre, 9);
  655.             existe = existe_lista(posible_nombre);
  656.  
  657.  
  658.             if(existe == -1)
  659.                 return -1;
  660.  
  661.             slist_destruir(Matriz[existe]->nodos);
  662.             free(Matriz[existe]);
  663.             for(; existe < cantidad_listas - 1 ; existe++)
  664.                 Matriz[existe] = Matriz[existe+1];
  665.  
  666.             Matriz = (Lista **) realloc (Matriz, sizeof(Lista *) * (cantidad_listas-1) );
  667.             cantidad_listas--;
  668.  
  669.             break;
  670.  
  671.  
  672.  
  673.         case 3:
  674.             copiar_nombre(buffer, posible_nombre, 9);
  675.             existe = existe_lista(posible_nombre);
  676.  
  677.             if(existe == -1)
  678.                 return -1;
  679.  
  680.             slist_recorrer(Matriz[existe]->nodos, imprimir_entero);
  681.             printf("\n");
  682.             break;
  683.  
  684.  
  685.  
  686.         case 4:
  687.             copiar_nombre(buffer, posible_nombre, 14);
  688.             existe = existe_lista(posible_nombre);
  689.  
  690.             if(existe == -1)
  691.                 return -1;
  692.  
  693.             copiar_nombre(buffer, posible_numero, 14 + strlen(posible_nombre) + 1);
  694.             dato = char_a_int(posible_numero);
  695.  
  696.             Matriz[existe]->nodos = slist_agregar_final(Matriz[existe]->nodos, dato);
  697.  
  698.             break;
  699.  
  700.  
  701.  
  702.         case 5:
  703.             copiar_nombre(buffer, posible_nombre, 15);
  704.             existe = existe_lista(posible_nombre);
  705.  
  706.             if(existe == -1)
  707.                 return -1;
  708.  
  709.             copiar_nombre(buffer, posible_numero, 15 + strlen(posible_nombre) + 1);
  710.             dato = char_a_int(posible_numero);
  711.  
  712.             Matriz[existe]->nodos = slist_agregar_inicio(Matriz[existe]->nodos, dato);
  713.  
  714.             break;
  715.            
  716.            
  717.         case 6:
  718.             copiar_nombre(buffer, posible_nombre, 12);
  719.             existe = existe_lista(posible_nombre);
  720.  
  721.             if(existe == -1)
  722.                 return -1;
  723.  
  724.             copiar_nombre(buffer, posible_numero, 12 + strlen(posible_nombre) + 1);
  725.             dato = char_a_int(posible_numero);
  726.             copiar_nombre(buffer, posible_posicion, 12 + strlen(posible_nombre) + 1 + strlen(posible_numero) + 1);
  727.             posicion = char_a_int(posible_posicion);
  728.  
  729.             Matriz[existe]->nodos = slist_insertar(Matriz[existe]->nodos, dato, posicion);
  730.  
  731.             break;
  732.  
  733.  
  734.  
  735.         case 7:
  736.             copiar_nombre(buffer, posible_nombre, 9);
  737.             existe = existe_lista(posible_nombre);
  738.  
  739.             if(existe == -1)
  740.                 return -1;
  741.  
  742.             printf("%d \n", slist_longitud(Matriz[existe]->nodos));
  743.  
  744.             break;
  745.  
  746.  
  747.         case 8:
  748.        
  749.             copiar_nombre(buffer, posible_nombre, 11);
  750.             existe = existe_lista(posible_nombre);
  751.  
  752.             if(existe == -1)
  753.                 return -1;
  754.  
  755.             copiar_nombre(buffer, posible_nombre2, 11 + strlen(posible_nombre) + 1);
  756.             existe2 = existe_lista(posible_nombre2);
  757.  
  758.             if(existe2 == -1)
  759.                 return -1;
  760.                
  761.             copiar_nombre(buffer, posible_nombre3, 11 + strlen(posible_nombre) + 1 + strlen(posible_nombre2) + 1);
  762.             existe3 = existe_lista(posible_nombre3);
  763.  
  764.             if(existe3 != -1)
  765.                 return -1;
  766.                
  767.                
  768.             cantidad_listas++;
  769.             Matriz = (Lista **) realloc (Matriz, (sizeof(Lista *) * cantidad_listas));
  770.             Matriz[cantidad_listas-1] = (Lista *) malloc (sizeof(Lista));
  771.             strcpy(Matriz[cantidad_listas-1]->nombre,posible_nombre3);
  772.             Matriz[cantidad_listas-1]->nodos = slist_crear();
  773.                            
  774.                            
  775.             Matriz[cantidad_listas-1]->nodos = slist_concatenar(Matriz[existe]->nodos, Matriz[existe2]->nodos);
  776.  
  777.             break;
  778.            
  779.            
  780.         case 9:
  781.             copiar_nombre(buffer, posible_nombre, 9);
  782.             existe = existe_lista(posible_nombre);
  783.  
  784.             if(existe == -1)
  785.                 return -1;
  786.  
  787.             copiar_nombre(buffer, posible_numero, 9 + strlen(posible_nombre) + 1);
  788.             dato = char_a_int(posible_numero);
  789.  
  790.             Matriz[existe]->nodos = slist_eliminar(Matriz[existe]->nodos, dato);
  791.  
  792.             break;
  793.            
  794.            
  795.         case 10:
  796.             copiar_nombre(buffer, posible_nombre, 9);
  797.             existe = existe_lista(posible_nombre);
  798.  
  799.             if(existe == -1)
  800.                 return -1;
  801.  
  802.             copiar_nombre(buffer, posible_numero, 9 + strlen(posible_nombre) + 1);
  803.             dato = char_a_int(posible_numero);
  804.            
  805.            
  806.             flag = slist_contiene(Matriz[existe]->nodos, dato);
  807.            
  808.             if (flag)  
  809.                 printf("SI\n");
  810.             else
  811.                 printf("NO\n");
  812.  
  813.             break;
  814.  
  815.        
  816.        
  817.         case 11:
  818.             copiar_nombre(buffer, posible_nombre, 7);
  819.             existe = existe_lista(posible_nombre);
  820.  
  821.             if(existe == -1)
  822.                 return -1;
  823.  
  824.             copiar_nombre(buffer, posible_numero, 7 + strlen(posible_nombre) + 1);
  825.             dato = char_a_int(posible_numero);
  826.  
  827.             slist_indice(Matriz[existe]->nodos, dato);
  828.  
  829.             break;
  830.        
  831.  
  832.         case 12:
  833.             copiar_nombre(buffer, posible_nombre, 11);
  834.             existe = existe_lista(posible_nombre);
  835.  
  836.             if(existe == -1)
  837.                 return -1;
  838.  
  839.             copiar_nombre(buffer, posible_nombre2, 11 + strlen(posible_nombre) + 1);
  840.             existe2 = existe_lista(posible_nombre2);
  841.  
  842.             if(existe2 == -1)
  843.                 return -1;
  844.                
  845.             copiar_nombre(buffer, posible_nombre3, 11 + strlen(posible_nombre) + 1 + strlen(posible_nombre2) + 1);
  846.             existe3 = existe_lista(posible_nombre3);
  847.  
  848.             if(existe3 != -1)
  849.                 return -1;
  850.                
  851.                
  852.             cantidad_listas++;
  853.             Matriz = (Lista **) realloc (Matriz, (sizeof(Lista *) * cantidad_listas));
  854.             Matriz[cantidad_listas-1] = (Lista *) malloc (sizeof(Lista));
  855.             strcpy(Matriz[cantidad_listas-1]->nombre,posible_nombre3);
  856.             Matriz[cantidad_listas-1]->nodos = slist_crear();
  857.                            
  858.                            
  859.             Matriz[cantidad_listas-1]->nodos = slist_intersecar(Matriz[existe]->nodos, Matriz[existe2]->nodos);
  860.  
  861.             break;
  862.            
  863.  
  864.         case 13:
  865.             copiar_nombre(buffer, posible_nombre, 8);
  866.             existe = existe_lista(posible_nombre);
  867.  
  868.             if(existe == -1)
  869.                 return -1;
  870.  
  871.             slist_ordenar(Matriz[existe]->nodos, mayor);
  872.  
  873.             break;
  874.              
  875.  
  876.     }
  877.     return resultado;
  878. }
  879.  
  880.  
  881. int main() {
  882.     char buffer[50];
  883.     int condicion = 1;
  884.     inicializar_comandos();
  885.     printf("Welcome to the house of fun\n\n");
  886.     while(condicion){
  887.         ingresar_comando(buffer);
  888.         condicion = interpretar_comando(buffer);
  889.         if (condicion == -1)
  890.             printf("ERROR \n");
  891.     }
  892.  
  893.    
  894.     return 0;
  895. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!