• Viernes 15 de Noviembre de 2024, 02:37

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - Miguel Ruiz

Páginas: [1]
1
C/C++ / [resuelto] Problema con violacion de segmento
« en: Sábado 31 de Marzo de 2018, 08:56 »
Hola a todos. Lo que pasa es que estoy trabajando con listas ligadas, el programa que estoy haciendo ya realiza algunas funciones, pero en la que me marca el error de violacion de segmento es cuando doy la opcion de realizar un recorrido del grafo y no se porque, las funciones que utilizo son unas que hice llamadas void recorrido() y void visitado(). en esa parte supongo que debe estar el error, una disculpa por poner el codigo completo pero es por si lo quieren correr. El error esta en la linea 344 en adelante que es donde hago mi funcion recorrido()
pd. El codigo esta sin terminar porque me atore en esta parte
    Modifico el post ya que ya corregi el problema que tenia, el fallo estaba en que hacia operaciones con direcciones invalidas(Si alguien quiere el codigo me lo puede decir)



Código: C
  1. //
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #define FALSO 0
  6.  
  7. typedef struct grafo{
  8.         struct grafo *vertice;
  9.         struct vertad *verticead;
  10.         char nombre[10];
  11.         int vis;
  12. }elemento_grafo;
  13.  
  14. typedef struct vertad{
  15.         struct vertad *verticead;
  16.         char nombre[10];
  17.         int vis;
  18. }elemento_vert;
  19.  
  20. typedef struct pilas{
  21.         struct pilas *sig;
  22.         char nombre[10];
  23. }pila;
  24.  
  25. void menu(int *op);
  26. elemento_grafo *Crearnodo();
  27. elemento_grafo Creararco();
  28. elemento_grafo *Agregarvertice(elemento_grafo *cabeza);
  29. elemento_grafo *buscar(elemento_grafo *cabeza,char nom[10]);
  30. void Mostrargrafo(elemento_grafo *cabeza);
  31. void Calculargrado(elemento_grafo *cabeza);
  32. elemento_grafo  *Eliminarvertice(elemento_grafo *cabeza, char nom[10]);
  33. void Recorrido(elemento_grafo *cabeza);
  34. void Limpiar(elemento_grafo *cabeza);
  35. void visitado(elemento_grafo *cabeza,char nom[10]);
  36. pila *empilar(pila *inicio, elemento_vert *tem , char nom[10]);
  37. pila *desempilar(pila *inicio, char nom[10]);
  38.  
  39. FILE *arch;
  40. int cont=0;
  41. int main(){
  42.   elemento_grafo *cabeza;
  43.   int op;
  44.   char nom[10];
  45.   arch = fopen("datos.txt","r+b");
  46.   cabeza = NULL;
  47.   if(arch != NULL){
  48.   printf("\n Programa de grafos con listas de adyacencia");
  49.   do{
  50.     menu(&op);
  51.     getchar();
  52.     printf("\n\n");
  53.     switch(op){
  54.       case 1:
  55.         cabeza = Agregarvertice(cabeza);
  56.         cont++;
  57.         break;
  58.       case 2:
  59.         Creararco(cabeza);
  60.         break;
  61.       case 3:
  62.         if(cabeza != NULL){
  63.           Mostrargrafo(cabeza);
  64.         }
  65.         else{
  66.           printf("\n Grafo no existe");
  67.         }
  68.         break;
  69.       case 4:
  70.         if(cabeza == NULL)
  71.           printf("\n No hay grafo que evaluar");
  72.         else
  73.           Calculargrado(cabeza);
  74.         break;
  75.       case 5:
  76.         if(cabeza != NULL){
  77.           printf("\n Si");
  78.           printf("\n Ingrese el vertice que quiere eliminar:\t");
  79.           scanf("%s",nom);
  80.           cabeza = Eliminarvertice(cabeza,nom);
  81.         }
  82.         else
  83.           printf("\n No existe grafo");
  84.         break;
  85.       case 6:
  86.         if(cabeza == NULL)
  87.           printf("\n Grafo vacio");
  88.         else
  89.           Recorrido(cabeza);
  90.         break;
  91.       default:
  92.         break;
  93.     }
  94.    }while(op!=9);
  95.   }
  96.   fclose(arch);
  97. }
  98.  
  99. void menu(int *op){
  100.     char    local;
  101.     printf("\n1> Ingresar vertice");
  102.     printf("\n2> Ingresar arco");
  103.     printf("\n3> Mostrar grafo");
  104.     printf("\n4> Mostrar grado de grafo");
  105.     printf("\n5> Eliminar vertice");
  106.     printf("\n6> Mostrar recorrido del grafo");
  107.     printf("\n7> Mostrar arbol de expansion minima");
  108.     printf("\n8> Mostrar arbol de camino mas corto");
  109.     printf("\n9> Salir");
  110.     printf("\n   Seleccione una opcion:\t");
  111.     do {
  112.         local = getchar ();
  113.         if ((isdigit (local) == FALSO) && (local != '\n')){
  114.             printf ("\nIngrese una opcion valida.\n");
  115.             printf("\n1> Ingresar vertice");
  116.             printf("\n2> Ingresar arco");
  117.             printf("\n3> Mostrar grafo");
  118.             printf("\n4> Mostrar grado de grafo");
  119.             printf("\n5> Eliminar vertice");
  120.             printf("\n6> Mostrar recorrido del grafo");
  121.             printf("\n7> Mostrar arbol de expansion minima");
  122.             printf("\n8> Mostrar arbol de camino mas corto");
  123.             printf("\n9> Salir");
  124.             printf("\n   Seleccione una opcion:\t");
  125.             //printf("\t");
  126.         }
  127.     } while (isdigit ((unsigned char) local) == FALSO);
  128.         *op = (int) local - '0';
  129. }
  130.  
  131. elemento_grafo *Crearnodo(){
  132.   elemento_grafo *nuevo;
  133.   char nom[10];
  134.   printf("\n Ingrese el nombre del vertice:\t");
  135.   //getchar();
  136.   scanf("%s",nom);
  137.   nuevo = (struct grafo*)malloc(sizeof(elemento_grafo));
  138.   nuevo->vertice = NULL;
  139.   nuevo->verticead = NULL;
  140.   nuevo->vis = 0;
  141.   strcpy(nuevo->nombre,nom);
  142.   return nuevo;
  143. }
  144.  
  145.  
  146. elemento_grafo *Agregarvertice(elemento_grafo *cabeza){
  147.   elemento_grafo *nuevo,*i;
  148.   if (cabeza == NULL){
  149.     nuevo = Crearnodo();
  150.     fputs(nuevo->nombre,arch);
  151.     return nuevo;
  152.   }
  153.   else{
  154.     nuevo = Crearnodo();
  155.     for (i = cabeza; i->vertice != NULL; i=i->vertice);
  156.     i->vertice = nuevo;
  157.     fputs(nuevo->nombre,arch);
  158.     return cabeza;
  159.   }
  160. }
  161.  
  162. elemento_grafo *buscar(elemento_grafo *cabeza, char nom[10]){
  163.   elemento_grafo *aux,*temp;
  164.   //char nom[10];
  165.   int f=0;
  166.   //printf("\n Ingrese los nodos:\n    ");
  167.   //getchar();
  168.   //fgets(nom,10,stdin);
  169.   //printf("\n %s",nom);
  170.   temp= NULL;
  171.   aux = cabeza;
  172.   while(f==0){
  173.     if(strcmp(aux->nombre,nom)==0){
  174.       //printf("/ Vertice encontrado");
  175.       temp = aux;
  176.       f = 1;
  177.     }
  178.     else
  179.       aux= aux->vertice;
  180.     if(aux == NULL)
  181.       f = 1;
  182.   }
  183.   return temp;
  184. }
  185.  
  186. elemento_grafo Creararco(elemento_grafo *cabeza){
  187.   elemento_grafo *ori,*des;
  188.   elemento_vert *nuevo1,*nuevo2,*i;
  189.   char nom[10];
  190.   int f=0;
  191.   if(cabeza != NULL){
  192.     printf("\n Ingrese el nodo origen:\t");
  193.     scanf("%s",nom);
  194.     ori = buscar(cabeza,nom);
  195.     //printf("\n Si");
  196.     if(ori != NULL){
  197.       printf("\n Ingrese el nodo destino:\t");
  198.       scanf("%s",nom);
  199.       des = buscar(cabeza,nom);
  200.       if(des != NULL){
  201.         nuevo1 = (struct vertad *)malloc(sizeof(elemento_vert));
  202.         nuevo1->verticead = NULL;
  203.         nuevo1->vis = 1;
  204.         nuevo2 = (struct vertad *)malloc(sizeof(elemento_vert));
  205.         nuevo2->verticead = NULL;
  206.         nuevo2->vis = 1;
  207.         strcpy(nuevo2->nombre,ori->nombre);
  208.         strcpy(nuevo1->nombre,des->nombre);
  209.         if(ori->verticead == NULL)
  210.           ori->verticead = nuevo1;
  211.         else{
  212.           for(i = ori->verticead; i->verticead!= NULL; i=i->verticead);
  213.           i->verticead = nuevo1;
  214.         }
  215.         if(des->verticead == NULL)
  216.           des->verticead = nuevo2;
  217.         else{
  218.           for(i= des->verticead; i->verticead != NULL; i=i->verticead);
  219.           i->verticead = nuevo2;
  220.         }
  221.       }
  222.       else{
  223.         printf("\n El nodo destino no existe");
  224.       }
  225.     }
  226.     else{
  227.       printf("El nodo origen no existe");
  228.     }
  229.   }
  230.   else{
  231.     printf("\n No hay suficientes vertices para crear arco");
  232.   }
  233. }
  234.  
  235. void Mostrargrafo(elemento_grafo *cabeza){
  236.   elemento_grafo *i,*aux;
  237.   elemento_vert  *j,*tem;
  238.   aux = cabeza;
  239.   int f=0,b=0;
  240.   while(f==0){
  241.     printf("%s",aux->nombre);
  242.     tem = aux->verticead;
  243.     while(tem != NULL){
  244.       printf(" -> %s",tem->nombre);
  245.       tem = tem->verticead;
  246.     }
  247.   aux = aux->vertice;
  248.   if(aux == NULL)
  249.     f=1;
  250.   printf("\n");
  251.   }
  252. }
  253. void Calculargrado(elemento_grafo *cabeza){
  254.   elemento_grafo *aux, *i;
  255.   elemento_vert  *tem;
  256.   int f=0,cont=0,b=0,grado=0;
  257.   aux = cabeza;
  258.   while(f == 0){
  259.     cont = 0;
  260.     b=0;
  261.     tem = aux->verticead;
  262.     while(b == 0){
  263.       if(tem == NULL){
  264.         b=1;
  265.       }
  266.       else{
  267.         cont++;
  268.         tem = tem->verticead;
  269.       }
  270.     }
  271.     aux = aux->vertice;
  272.     if(cont>=grado){
  273.      grado = cont;}
  274.     if(aux == NULL){
  275.       f=1;}
  276.   }
  277.   printf("\n El grado del grafo es:  %d",grado);
  278. }
  279.  
  280. elemento_grafo *Eliminarvertice(elemento_grafo *cabeza, char nom[10]){
  281.   elemento_grafo *pos,*aux,*i;
  282.   elemento_vert  *tem,*j;
  283.   int f=0,b=0;
  284.   printf("\n %s",nom);
  285.   pos = buscar(cabeza,nom);
  286.   if(pos != NULL){
  287.     aux = cabeza;
  288.     if(pos == aux){
  289.       aux =aux->vertice;
  290.       cabeza = aux;
  291.     }
  292.     else
  293.     if(pos->vertice == NULL){
  294.       while(aux->vertice != pos)
  295.         aux = aux->vertice;
  296.     aux->vertice = NULL;
  297.     }
  298.     else{
  299.       while(aux->vertice != pos)
  300.         aux = aux->vertice;
  301.       i = aux->vertice;
  302.       i = i->vertice;
  303.       aux->vertice = i;
  304.       //return cabeza;
  305.     }
  306.   }
  307.     aux = cabeza;
  308.     while(aux != NULL){
  309.       printf("\n Entra");
  310.       b = 0;
  311.       tem = aux->verticead;
  312.       if(tem != NULL)
  313.         while(tem != NULL){
  314.           if(strcmp(tem->nombre,nom)== 0){
  315.             if(tem->verticead == NULL && aux->verticead == tem)
  316.               aux->verticead = NULL;
  317.             else
  318.             if(tem->verticead == NULL){
  319.               j= aux->verticead;
  320.               while(j->verticead != NULL)
  321.                 j = j->verticead;
  322.               j->verticead = NULL;
  323.             }
  324.             else
  325.             if(aux->verticead == tem){
  326.               tem->verticead;
  327.               aux->verticead = tem;
  328.             }
  329.             else
  330.             if(tem->verticead == NULL){
  331.               j= aux->verticead;
  332.               while(j->verticead != tem)
  333.                 j = j->verticead;
  334.               tem = tem->verticead;
  335.               j->verticead = tem;
  336.             }
  337.           }
  338.           tem = tem->verticead;
  339.         }
  340.       aux = aux->vertice;
  341.     }
  342.   return cabeza;
  343. }
  344.  
  345. void Recorrido(elemento_grafo *cabeza){
  346.   char nom[10];
  347.   int nodos=cont;
  348.   elemento_grafo *aux,*final;
  349.   elemento_vert  *tem,*j,*i;
  350.   pila *dir,*inicio=NULL;
  351.   printf("\n Desde que nodo desea realizar el recorrido:\t");
  352.   scanf("%s",nom);
  353.   aux = buscar(cabeza,nom);
  354.   if(aux == NULL){
  355.     printf("\n El vertice dado no existe");}
  356.   else{
  357.     int f=0,b=0;
  358.     printf("\n%d",cont);
  359.     while(f == 0 ){
  360.       if(nodos >= 0){
  361.         printf("%s",aux->nombre);
  362.         printf("->");}
  363.       tem = aux->verticead;
  364.       b = 0;
  365.       while(b == 0){
  366.         if(tem->vis == 1)
  367.           tem = tem->verticead;
  368.         else{
  369.           j = tem;
  370.           strcpy(nom,tem->nombre);
  371.           while(j != NULL){
  372.             if(strcmp(nom,j->nombre) > 0 && j->vis != 1){
  373.               printf("(%s)>(%s)",nom,j->nombre);
  374.               strcpy(nom,j->nombre);
  375.               i = j;
  376.               j = j->verticead;}
  377.             else
  378.               j = j->verticead;
  379.           }
  380.            b=1;
  381.         }
  382.         //tem = tem->verticead;
  383.         //if( tem->verticead == NULL || tem == NULL)
  384.          //b = 1;
  385.       }
  386.       visitado(cabeza,nom);
  387.       aux = buscar(cabeza,nom);
  388.       nodos--;
  389.       if(nodos == 0)
  390.         f = 1;
  391.     }
  392.     printf("\n%d",nodos);
  393.   }
  394. }
  395.  
  396.  
  397. pila *empilar(pila *inicio, elemento_vert *tem , char nom[10]){
  398.  
  399. }
  400.  
  401. pila *desempilar(pila *inicio, char nom[10]){
  402. }
  403.  
  404. void visitado(elemento_grafo *cabeza, char nom[10]){
  405.   elemento_grafo *aux;
  406.   elemento_vert  *tem;
  407.   int f=0,b=0;
  408.   aux = cabeza;
  409.   while( aux != NULL){
  410.     if(strcmp(nom,aux->nombre) == 0){
  411.       aux->vis = 1;
  412.       aux = aux->vertice;}
  413.     tem = aux->verticead;
  414.     while( tem != NULL){
  415.       if(strcmp(nom,tem->nombre) == 0){
  416.         tem->vis = 1;
  417.         tem = tem->verticead;}
  418.       else
  419.         tem = tem->verticead;
  420.     }
  421.     aux = aux->vertice;
  422.   }
  423. }

Páginas: [1]