Red de conocimiento informático - Consumibles informáticos - Programación de pila de cadenas

Programación de pila de cadenas

Resolver un problema de laberinto consiste en encontrar todos los caminos desde la entrada hasta la salida. A la hora de resolver se suele utilizar el método del "método exhaustivo", es decir, partir de la entrada, explorar en una determinada dirección, y si se puede abrir, seguir avanzando; de lo contrario, regresar por el camino original y continuar probando en el; otra dirección hasta que se prueben todas las soluciones posibles.

#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

}

mientras(S2)

{

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");

}