Resolución de laberintos del algoritmo de estructura de datos (lenguaje c)
Los comentarios son muy detallados y espero que os sean de ayuda.
#include
#include
#defineM15
#defineN15
structmark//Definir los puntos interiores del tipo de coordenadas del laberinto
{
intx
inty
}; Elemento de pila, oye, oye. .
{
intx, y; //x fila, y columna
intd; //d dirección del siguiente paso
} ;
typedefstructLStack//pila de cadena
{
Elementelem;
structLStack*next;
}* PLStack;
/******************Función de pila****************/
intInitStack (PLStack
return1;
}
intStackEmpty(PLStackS)//Determine si la pila está vacía
{
if(S==NULL)
return1;
else
return0;
}
intPush(PLStack
p=(PLStack)malloc(sizeof(LStack));
p-gt; elem=e;
p-gt; siguiente =S;
S=p;
return1;
}
intPop(PLStack
if( !StackEmpty(S))
{
e=S-gt;elem;
p=S;
S=S -gt; siguiente;
gratis(p);
retorno1
}
otro
p>return0 ;
}
/******************Encuentra la función de ruta del laberinto**** ************** *********/
voidMazePath(structmarkstart, structmarkend, intmaze[M][N], intdiradd[4][ 2])
{
inti, j, d; inta, b;
Elementelem, e
PLStackS1, S2;
InitStack(S1);
p>
InitStack(S2);
laberinto[start.x][start.y]=2; //Marcar el punto de entrada
elem.x=start .x;
elem.y=start.y;
elem.d=-1; //Comienza con -1
Push(S1, elem );
while(!StackEmpty(S1))//La pila no está vacía y hay un camino a seguir
{
Pop(S1, elem);
i=elem.x
j=elem.y
d=elem.d 1; //Siguiente dirección
while(d
{
a=i diradd[d][0] ;
b=j diradd[d][1];
p>if(a==end.x
elem.y=j;
elem.d=d;
Push(S1, elem);
elem.x=a; b;
elem.d=886; // Juicio de que la dirección de salida es -1 ¿Has llegado a la salida?
Push(S1, e
lem);
printf(\n0=Este 1=Sur 2=Oeste 3=Norte 886 entonces podrás salir del laberinto\n\nLa ruta es: (coordenadas de fila, coordenadas de columna, dirección) \n);
while(S1)//Invierte la secuencia y genera la secuencia del camino del laberinto
{
Pop(S1, e);
Empujar(S2, e);
}
mientras(S2)
{
Pop(S2, e);
p>printf(--gt; (d, d, d), e.x, e.y, e.d
}
return; // Salgo del bucle de dos niveles. Originalmente usé break, pero encontré un error y salir finalizará el programa. Es mejor elegir return
}
if. (laberinto[a][b]==0)//Encontré un punto sin salida donde puedes avanzar
{
laberinto[a][b]=2; // Marca este punto como pasado
elem.x= i;
elem.y=j
elem.d=d; >
Push(S1,elem); //La posición actual se empuja a la pila
p>i=a //El siguiente punto se convierte en el punto actual
<; p>j=b;d=-1;
}
d;
}
}
printf(No se encontró ningún camino para salir de este laberinto\n);
}
/********** *******Crea un laberinto************************/
voidinitmaze(intmaze[M][N ])
{
inti, j;
intm, n; //laberinto de filas, columnas[/ M]
printf (ingrese el número de filas en el laberinto m=);
scanf (d,
printf (ingrese el número de columnas en el laberinto n=);
scanf(d,
printf(\nIngrese las filas y columnas del laberinto:\nSepare con espacios, 0 representa el camino, 1 representa la pared\n, m, n);
for(i=1; i
for(j=1; j
scanf(d,
printf (El laberinto que construiste es (el círculo más externo es la pared)...\n);
for(i=0; i
{
laberinto [i ][0]=1;
laberinto[i][n 1]=1;
}
for(j=0;j
{
laberinto[0][j]=1
laberinto[m 1][j]=1
}
for(i=0; i
{
for(j=0; j
printf(d, laberinto[i ][ j]);
printf(\n);
}
}
voidmain()
{
intsto[M][N];
structmarkstart, end; //inicio, coordenadas finales de entrada y salida
intadd[4] [2 ]={{0, 1}, {1, 0}, {0, -1}, {-1, 0}} // Las direcciones de incremento de fila y de columna son este, oeste, norte, sur [/M ]
initmaze(sto); //Crea un laberinto
printf (ingresa la coordenada horizontal de la entrada, la coordenada vertical [separada por comas]\n);
< pag>scanf(d, d,
printf (ingrese la coordenada de abscisas de la salida, ordenadas [separadas por comas]\n);
scanf(d, d,
MazePath(start, end, sto, add); //findpath
system(PAUSE);
}
Datos de prueba, complejidad del algoritmo Solo Escríbalo usted mismo. Si ni siquiera hace esto usted mismo, entonces debe estar haciendo la tarea. Le sugiero que haga el examen usted mismo, no sea que el maestro le pregunte durante la defensa y no sepa nada, entonces lo hará. estar en problemas. ¡Buena suerte!