¡Por favor ayúdenme urgentemente! Diseño del curso de estructura de datos en C en gráficos de viajes.
#include "malloc.h"
#include "string.h"
#define INFINITY 32767 /* Máximo gráfico peso, 32767 es el valor máximo expresado como un número entero*/
##define MAX_VALUE 30 /* Número máximo de vértices*/
#define MAX_VEX 30 /* Número máximo de vértices */
#define MAX_VALUE 99999999999
typedef int InfoType;
typedef char VexType
typedef enum{DG =1, AG; =2 ,WDG=3,WAG=4}GraphKind;
typedef struct Path
{
intvertex[MAX_VEX];
intvalue;
intcount;
}GPath;
typedef estructura MGraph
{
charvexs[MAX_VEX] ; / *Guardar los vértices y vectores de vértices de la matriz de adyacencia del gráfico*/
intarcs[MAX_VEX][MAX_VEX] /*Guardar los bordes de la matriz de adyacencia del gráfico*/
intvexnum,arcnum; /* Recuento de vértices y arcos del gráfico actual*/
}MGraph /* Definición de la estructura del gráfico después de convertir la lista de adyacencia del gráfico en una matriz*/
/* Adyacencia del gráfico Definición de estructura de nodo en la estructura de almacenamiento matricial*/
typed
typedef struct Linknode
{
charadjvex;/* El punto adyacente está en Posición en la matriz de nodos principales (número de vértice principal del arco del borde adyacente) */
InfoTypeinfo /* Información relacionada con el borde o arco, como como valor de peso*/
structLinknode * nextarc /* Apunta al siguiente nodo de la tabla*/
}LinkNode /* Estructura de nodo para una única lista vinculada de bordes adyacentes*/
typedef struct VexNode
{
char data; /* Campo de datos utilizado para almacenar información de vértices.
*/
int in Degree; /* El grado del vértice, ya sea que el gráfico dirigido sea interno o externo */
LinkNode *firstarc /* El campo de enlace apunta al primero. Nodo de tabla (puntero de cabecera de borde adyacente) */
}VexNode; /* Definición del tipo de nodo de vértice*/
typedef struct
{
GraphKind kind; /* Bandera de tipo de gráfico*/
intvexnum; /* Número de vértices*/
VexNodeAdjList[MAX_VEX] /* Matriz de lista de adyacencia*/
}ALGraph; /* Definición de estructura gráfica*/
typedef struct
{
VexType vex1, vex2 /* Conectado a arcos o aristas. Dos vértices*/
InfoTypeinfo; /* Información relacionada con aristas o arcos, como pesos*/
}ArcType; /* Definición estructural de arcos o aristas*/
void Init_Graph(ALGraph * G) /* Inicialización del gráfico*/
{
do
{
printf ("Por favor confirme el tipo de atracción turística (1: Gráfico no dirigido. 2: Gráfico dirigido. 3).2: Gráfico dirigido. 3: Gráfico dirigido ponderado. 4: Gráfico no dirigido ponderado):/n" ;
scanf("%d",&G->kind)
if(G->kind==4)
printf("Tipo de visita guiada al atractivo turístico mapa: gráfico no dirigido ponderado\n");
else
{
printf(" ● El tipo de gráfico que seleccionó es incorrecto●\ n");
}
}
}
mientras(G->tipo!=4);
G ->vexnum=0; /* Inicializa el número de vértices en 0 */
}
int
LocateVex(ALGraph *G, VexType vp)
/* La posición de los vértices del gráfico (la posición de los vértices del gráfico en realidad determina el contenido del campo de datos de vértice de un elemento en la matriz AdjList).
*/
{
int k;
for(k=0;k
si (G->AdjList[k].data==vp)
return(k); /* Si el vértice existe, devuelve el valor del subíndice de la matriz de vértices*/
return ( -1); /* Si no existe, devuelve -1 (el vértice no existe en el gráfico) */
}
int AddVertex(ALGraph *G, char vp) / * Agregar un vértice al gráfico (agregar un vértice al gráfico agrega un elemento de datos al final de la matriz AdjList) */
{ int k;
if (G-> vexnum>=MAX_VEX)
{
printf("¡Se ha alcanzado el número máximo de vértices en el gráfico! \n");
return(- 1);
}
if(LocateVex(G,vp)!=-1)
{
printf("¡El vértice a agregar ya existe!\n");
return(-1);
}
G->AdjList[G ->vexnum] .data=vp;
G->AdjList[G->vexnum].ingree=0;
G->AdjList[G->vexnum].firstarc =NULL;
k=++G->vexnum;
Devuelve k;
}
int AddArc(ALGraph *G , ArcType *arc )/* Agregue un borde (arco) al gráfico de Agregar un borde (arco) (Modifique una lista enlazada única según los vértices conectados por el arco o borde especificado: el gráfico no dirigido modifica dos listas enlazadas individualmente; )*/
{
int k,j;
LinkNode*p,*q;
k=LocateVex(G, arc->vex1);
j =LocateVex(G,arc->vex2);
if(k==-1||j==-1) /* Primero determina si los dos vértices están repetidos o si ambos vértices existen*
{
printf("Los dos puntos son un solo punto o ninguno existe, ¡error! \n");
return(-1);
}
p=(LinkNode*)malloc(sizeof(LinkNode));
p->adjvex=arc->vex1;
p->info=arc ->info;
p->nextarc=NULL;/* Comenzar con borde Nodo de la tabla de asignación*/
q=(LinkNode*)malloc(sizeof(LinkNode));
q->adjvex=arc->vex2;
q->info=arc->info;
q->nextarc=NULL /* Finalizar la asignación de nodos de la tabla para los bordes
*/
q->nextarc=G->AdjList[k].firstarc;
G->AdjList[k].firstarc=q;
p->nextarc=G->AdjList[j].firstarc;
G->AdjList[j].firstarc=p
/*
; Este es un gráfico no dirigido, con encabezados insertados en dos listas enlazadas individualmente*/
return(1);/* Gráfico no dirigido, que conecta p y q con los puntos de borde de cada uno*/
}
ALGraph *Create_ALGraph()/* Utilice listas enlazadas de adyacencia como estructuras de almacenamiento de gráficos para construir gráficos dirigidos ponderados*/
{
charstack1[MAX_VEX] ,stack2[MAX_VEX],vex,k1,k2;
intweight;
ALGraph*G;
ArcType*p;
p>
printf("Primero inicialice el mapa guía de la zona turística:\n");
G=(ALGraph*)malloc(sizeof(ALGraph));//aplicar espacio de nodo dinámico
Init_Graph(G);
printf("\nPor favor ingrese el código de cada atracción turística del mapa guía de la zona turística (dentro y fuera de la forma de caracteres), al ingresar 0 como marca final \n");
while(1)
{
scanf("%s",stack1);/* como cadena Enter las atracciones turísticas se almacenarán en forma de /p>
if(vex=='0')
break;
else
AddVertex( G,vex);
}
p=( ArcType*)malloc(sizeof(ArcType));
printf("/n
Construya un mapa de las atracciones turísticas en esta zona turística a partir de la entrada del teclado en forma de (Vi,Vj
,d),\n donde: Vi y Vj representan dos atracciones diferentes, y d representa la distancia del camino entre estas atracciones.
distancia;\n
El mapa de atracciones turísticas utiliza una estructura de almacenamiento de lista vinculada de adyacencia (cuando el primer vértice de entrada es 0, indica el final):\n");
mientras (1 )
{
scanf("%s",stack1);
k1=stack1[0];
si ( k1 =='0') /* Ingrese el primer vértice, termine con 0*/
break
else
{
<; p> scanf("%s",stack2);scanf("%d",&weight)
/*
Ingrese el segundo vértice y peso*/
k2=stack2[0];
p->vex1=k1;
p->vex2=k2;
p->info=weight;
AddArc(G,p);
printf( "\n¡¡¡Continúe escribiendo la siguiente carretera!!!!\n") ;
}
}
return(G);
}void output_ALGraph(ALGraph *G) // 2: Gráfico de salida Lista enlazada de adyacencia
{
int j;
LinkNode*p;
p> printf("\n Mapa guía de zonas turísticas La salida de las atracciones de la lista enlazada de adyacencia es la siguiente:\n");
for(j=0;j
{
printf ("%c",G->AdjList[j].data);
p=G->AdjList[j].firstarc;
while( p!=NULL) //Después de generar una lista vinculada adyacente de atracciones, continúe generando sus otras atracciones adyacentes
{
printf("-> ");
printf("<%c ,%d>",p->adjvex,p->info);
p=p->nextarc;
}printf ("\ n\n");
}}
void
output_Find_ALGraph( ALGraph *G)
// 4: Atracción adyacente Forzar búsqueda y salida
{
int j;
LinkNode*p; //definir el nodo de tabla vinculado individualmente del borde vecino p
printf("Ingrese la atracción que desea buscar (valor de subíndice de la matriz de vértices)：\n" //desde la atracción de entrada, comience a buscar atracciones adyacentes y genere los pesos
scanf (" %d",&j);
p=G->AdjList[j].firstarc //Definir el puntero principal adyacente
while(p!=NULL)
{
printf("De la atracción %c a la atracción %c
La distancia es %d (la carretera que conecta las dos atracciones)/n",G->AdjList[j].data,p->adjvex,p->info);//La j-ésima atracción y la siguiente Atracciones adyacentes y pesos
p=p->nextarc; // Apunta a la siguiente dirección del nodo, de modo que G->AdjList[j].data sean todos generados, con corte en NULL
}
printf("\n\n");
}
void ListToMat(ALGraph G, MGraph&g) /* Convertir lista enlazada de adyacencia a matriz de adyacencia */
{
intk,i,j
LinkNode*p;
for
< p; >(i=0;ig.arcs[i][j]=INFINITY;
for(i=0;i { g.vexs[i]= G.AdjList[i].data /* Vinculará El; Los vértices de la matriz de la lista se guardan en la matriz vexs[i]*/ } for(i=0;i p=G.AdjList[i].firstarc; while(p!=NULL) { k=LocateVex (&G,p->adjvex); /* Obtenga el valor del subíndice del vértice adyacente a p y utilícelo como el valor del subíndice de la matriz de adyacencia*/ g.arcs[i] [k]=g .arcs[k][i]=p->info ;/* Asignar pesos a una matriz bidimensional para la salida matricial*/ p=p->nextarc /* Apunte a la siguiente lista de adyacencia Node*/ } } } g.vexnum=G.vexnum; } visualización vacía( ALGraph *G,MGraph g) /*3: Matriz de adyacencia de salida*/ { inti,j ; ListToMat(*G,g); /*Convertir lista enlazada de adyacencia en matriz de adyacencia*/ printf(" "); for(i =0;i printf("%-8c",G->AdjList[i].data);/*Valor del vértice horizontal de la matriz de salida*/ printf( "/n"); for(i=0;i { printf( "%c ",G ->AdjList[i].data /* Genera valores de vértice vertical de matriz, genera un vértice por fila* for(j=0;j { if(g.arcs[i ][j]==INFINITY) printf("∞ "); else printf("%-8d",g.arcs[i][j]);/* Cada peso ocupa 8 caracteres y el signo negativo indica alineación del extremo izquierdo*/ } impresión tf("\n") ) } } void dijkshort_One(ALGraph F, MGraph G,intv0,int distancia[], int ruta[ ])/*La distancia más corta del gráfico ponderado G desde el vértice v0 a otros puntos fijos y el subíndice del nodo anterior de la ruta más corta*/ //Gráfico ponderado F del subíndice v0 a otros vértices La distancia más corta diatancia y el subíndice de la ruta más corta, la ruta guarda el subíndice del vértice anterior de la ruta más corta desde la entrada v0 a cada otro vértice // Diseño de funciones basado en Dijkstra { int*S =(int *)malloc(sizeof(int)*G.vexnum); intminDis,i,j,u,p; ListToMat(F,G); printf("Los lugares que desea iniciar la consulta son:%c\n",F.AdjList[v0].data); for(i=0;i { distancia[i]=G.arcs[v0][i ]; S[i]=0; if(distancia[i]<.INFINITY) ruta[i]=v0; else ruta[i]=-1; } S[v0]=1 //Marcar vértice v0 ha sido eliminado; del conjunto T se suma al conjunto S (v0 es el vértice con un valor de subíndice) for(i=0;i< ;G.arc[v0][i]; S[v0 ]=0; if(distancia[i]<.vxnum;i++) { minDis=INFINITY for (j=0;j { if(S[j]==0&& distancia[j]< minDis) { minDis=distancia[j]; u=j; } } S[u]=1; //Marca el vértice u agregado del conjunto T al conjunto S (el vértice con u como valor de subíndice) for(j=0; j<G. vexnum; j++) } S[u]=1. { distancia[j]= distancia[u]+G .arcs[u][j];//La distancia más corta y el camino más corto desde el vértice v0 hasta el vértice u hasta otros vértices path[j]=u; } }//La distancia más corta de todos los vértices se ha almacenado en la distancia de matriz printf("El resultado de la consulta es:\n"); for(j=0 ;j if(path[j]! =-1) { printf("del vértice %c al vértice %c",F.AdjList[v0].data,G.vexs[j]); p =ruta[j]; imprimir f("la distancia más corta desde el vértice v0 al vértice v0 es: %d",distance[j]);// genera la ruta más corta desde el vértice v0 a todos los demás vértices printf("Los puntos de los intereses transferidos en el camino son:"); while(p!=-1) { printf("%c",G.vexs [p]); p=ruta[p]; } printf("\n"); } elseif(j!=v0) printf("\n%c a %c: ¡sin ruta!" ,G.vexs[j],G.vexs[v0] );}