Programación de pila de cadenas
#incluye & ltstdio.h & gt
#incluye & ltstdlib.h & gt
#Definición M 15
#Definición Número 15
Marca de estructura //Define el tipo de coordenadas del punto central del laberinto.
{
int x;
int y;
};
Elemento de estructura // "Amor "Elemento de pila, jaja. .
{
int x, y; //x fila, columna Y
int d; //d siguiente dirección
} ;
Estructura Typedef LStack //pila de cadena
{
Elemento elem
estructura LStack * siguiente
} * PLStack
/* * * * * * * * * * * *Función de pila* * * * * * * * * * * * * * *
int init stack (pl stack & amp; S)//Construir una pila vacía
{
S = NULL
Return 1;
}
Int StackEmpty(PLStack S)//Determina si la pila está vacía.
{
if(S==NULL)
Devuelve 1;
Otros
Devuelve 0;
}
int Push(pl stack & s, Element e)//Presiona el nuevo elemento de datos.
{
pl pila p;
p =(pl pila)malloc(tamañode(LStack));
p-> ; elem = e;
p->; siguiente = S;
s = p; /p>
int Pop(pl stack & amp; element & ampE) //Abre el elemento superior de la pila.
{
pl pila p;
if (! parte superior de la pila)
{
e = S ->elem
p = S;
S = S->Siguiente;
Gratis(p);
Devuelve 1;
}
Otro
Devuelve 0
}
/* * * * * * * * * * * *Función de búsqueda de ruta de laberinto* * * * * * * * * * * * * * * * * *
ruta de laberinto vacía (inicio de marca de estructura, final de marca de estructura, laberinto interno
[N], int diradd[4][2])
{
int i, j, d; int a, b < /p; >
Elemento elem, e;
S2 pl pila s 1;
pila inicial(s 1);
pila inicial(S2) ;
maze[start . x][start . y]= 2; //Marca el punto de entrada.
elem . x = start .
Push(S1,elem);
Y (!StackEmpty(S1)) //La pila no está vacía. Hay un camino por recorrer.
{
Pop(S1,elem);
i = elem.x
j = elem.y
d = elem . d+1; //Siguiente dirección
while(d <4) // Explora sureste, noroeste, sureste en todas las direcciones.
{
a = I+diradd[d][0]
b = j+diradd[d][1];
si(a = = fin . >elem .
elem .
Empuja (S1, elem);
Printf("\n0=Este 1=Sur 2=Oeste 3=Norte 886, y luego sal del laberinto\n \nEl la ruta es: (coordenadas de fila, coordenadas de columna, dirección)\n ");
While(S1) //Invierte la secuencia y genera la secuencia de ruta del laberinto.
{
Pop(S1, e);
Empujar(S2, e
}
{
Pop(S2, e);
printf("-& gt; (%d, %d, % d ) ", e. . Sigue siendo una buena opción para volver. O (∩ _ ∩) O. ...
}
If(maze[a][b]==0) //Encuentra un punto sin salida que pueda avanzar.
{
Laberinto[a][b]= 2; //Marca el paso de este punto
elem .
elem.y = j;
elem.d = d
push(S1,elem); //La posición actual está apilada.
I = a; //Convierte el siguiente punto al punto actual.
j = b;
d =-1
}
d++; p>
}
Printf("No hay forma de salir de este laberinto\ n "
}
/* * * * * * *); * * * * *Construye un laberinto* * * * * * * * * * * * * *
laberinto inicial vacío (int laberinto
[N])
{
int i, j;
int m, n; //laberinto de filas, columnas
Printf("Ingrese las filas en el laberinto Número m = ");
scanf("%d ", & ampm);
Printf("Ingrese el número de columnas en el laberinto n = ");
scanf("%d ",& ampn);
printf(" \nIngrese las filas y columnas del laberinto:\n Separe con espacios, 0 representa el camino, 1 representa la pared\n " , m, n);
for(I = 1; i & lt= m; i++)
for(j = 1; j & lt= n; j++)
scanf("%d ", & ampmaze[I][j]);
Printf("El laberinto que construiste es o(∩_∩)o ...\ n " );
for(I = 0;i<= m+1;I++) //Añadir valla.
{
Laberinto[I][0]= 1;
Laberinto[I][n+1]= 1;
}
for(j = 0; j & lt= n+1; j++)
{
Laberinto[0][j]= 1;
Laberinto[m+1][j]= 1
}
for(I = 0;I<= m+1;I++) // Laberinto de salida
{
for(j = 0; j & lt= n+1; j++)
printf("%d ",laberinto [I ][j]);
printf(" \ n ");
}
}
void main()
{
Sto interno
[N];
Marca de estructura inicial y final //El punto inicial y final de la entrada; y salir Coordenadas
int add[4][2]={{0, 1}, {1, 0}, {0, -1}, {-1, 0 } }; incremento La dirección del incremento de la columna de suma es este, oeste, norte y sur.
init maze(sto); //Construye un laberinto
Printf("Ingresa la abscisa y la ordenada de la entrada [separadas por comas]\ n ");
scanf("%d, %d ", & ampstart .
scanf("%d, %d ",&end.x &end.y);
Laberinto (inicio, fin, sto, agregar); //Buscar ruta
Sistema("pausa");
}