SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: Miguel Ruiz en Sábado 31 de Marzo de 2018, 08:56

Título: [resuelto] Problema con violacion de segmento
Publicado por: Miguel Ruiz 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
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. }
Título: Re:[resuelto] Problema con violacion de segmento
Publicado por: Eternal Idol en Lunes 30 de Abril de 2018, 10:35
Tenes que depurarlo, no te queda otra.