Análisis del código fuente del asiento

Demostración de MazePath de Turbo C 2.0

Todos los derechos reservados. Reservados todos los derechos.

Nombre del archivo: Maze.c

Autor Dong Chengyu.

Versión 1.10

*/

# incluir & ltstdio.h & gt

# incluir & ltstdlib.h & gtp>

#incluye & ltmalloc.h & gt

# incluye & ltconio.h & gt

#incluye & ltdos.h & gt

#definir OK 1

#definir error 0

#definir verdadero 1

#definir falso 0

#definir F9 0x43

#define Esc 0x1b

#define Del 0x53

#Definición página de inicio 0x47

#Definición final 0x4f

# Definición espacio 0x20

#Definición hacia arriba 0x48

#Definición hacia abajo 0x50

#Definición izquierda 0x4b

#Definición derecha 0x4d

#definir entrada 0x0d

#definir F2 0x3c

#definir F3 0x3d

#definir STACK_INIT_SIZE 200

#Definir incremento de pila 10

typedef int booleano

typedef int status;

estructura typedef

{

int x;

int y;

}

PosType

estructura typedef

{

int orden;

Asiento trasero;

int di

}

SElemType

typedef estructura

{

int td

int pie

int etiqueta;

}

MazeType

estructura typedef

{

SElemType * base

SElemType * top

int tamaño de pila

}

pila;

int Laberinto[20][30];

LaberintoTypelaberinto[20][30]; >

PosType StartPlace

Posición final del tipo de publicación;

int count

int m, n

Boolean b_start = FALSE, b_end = FALSE

void creat maze(void);

Estado guardar laberinto(char *nombre de archivo);

Estado cargar laberinto(char * nombre de archivo) ;

error nulo (char * mensaje);

estado init Stack(Stack * s);

estado destroy Stack(Stack * s);

Estado claro Pila(Pila * s);

Pila booleana Vacío(Pila * s);

int Longitud de pila (Pila * s));

Estado Push(Stack *s, selem tipo e);

SElemType Pop(Stack *s, selem tipo e);

Estado GetTop( Pila *s, selem tipo * e);

Estado Stac

kTraverse(Stack *s, Status(* visit)(selem type * se));

Transferencia booleana (PosType curpos);

impresión de marca nula (PosType asiento);

p>

Huella vacía (PosType curpos);

PosType NextPos(PosType asiento, int di);

Estado MazePath (comienza el último tipo, el siguiente tipo termina);

p>

Creación no válida (no válida)

/**/ /* Forma un laberinto. */

{

error nulo (char * mensaje);

Estado guardar laberinto (char * nombre de archivo);

Estado de carga laberinto(char * nombre de archivo);

int i, j;

int x, y

char c; [12], nombre de carga[12];

Indicador booleano = falso, carga = falso;

clr SCR();

printf(" Menú:\ n \ n ");

printf("1. Cargando Mazefile:(*.DD)\ n \n ");

printf("2.

Ingrese al laberinto:\ n \ n ");

printf("Ingrese su elección:");

Hacer

{

c = getch();

Cambiar(c)

{

case ' 1 ':patch(' 1 ');

caso "2": putch("2"); descanso

Caso Esc: dormir (1); salida

Predeterminado: descanso

}

}

Y (c!= ' 1 ' & & ampc!= '2') ;

if ( c == '1 ')

{

printf(" \ n \ nLoadName:");

scanf("%s ", nombre de carga);

if (LoadMaze(loadname))

{

Sleep(1) = TRUE

}

else { gotoxy(1, 9); printf("¡Error al cargar!");}

}

if (! load)

{

printf("\nIngrese el tamaño del laberinto:\n");

printf("\nIngrese la longitud:\n");

scanf (" %d ", &m);

printf("\nAncho de entrada:\n");

scanf("%d",&n);

p>

if (m & lt4 | | n & lt4) error ("entrada");

if (m & gt30 | ;

for(I = 0; i<30;i++)

for(j = 0;j<20;j++)

Laberinto[j] [I]= 2;

lugar de inicio x =. 0;

lugar inicial . y = 0;

lugar final x = 0;

lugar inicial . ;

clr SCR();

printf(" \ n "

for(I = 1 ; i & lt= n; i++)

{

for(j = 1; j & lt= m; j++)

{

printf(" # ");

Laberinto[I-1][j-1]= 0;

}

printf("\n");

}

}

gotoxy(65, 5);

printf(" ' # ':Pared " ); (65, 7);

printf(" Inicio:Inicio ");

gotoxy(65, 9);

printf(" Fin:Fin ").

gotoxy(65, 11);

printf("Eliminar muro:Del ");

gotoxy(65, 13); >

printf("Entrar en la pared:Entrar ");

gotoxy(65, 15

printf("Guardar el laberinto :F2 ");

gotoxy(65,17);

printf("Completo:F9 ");

gotoxy(65,19);

printf(" Salir:Esc

");

gotoxy(4, 3);

x = 4; y = 3;

Hacer

{

c = getch();

Cambiar (c)

{

caso arriba:if(y & gt; 3){ y -;gotoxy(x,y);}

Descanso;

caso abajo:if(y <n){ y++;gotoxy(x,y);}

Pausa;

Caso restante: if (x & gt4) { x-= 2; gotoxy(x, y);}

Pausa;

caso Derecha:if(x<2*m-2){x+=2;gotoxy(x,y);}

Descanso;

caso Del: si (y-2 == lugar de inicio. y & amp; & ampx/2-1 == lugar de inicio. x)b _ inicio = FALSE

if(y-2 == lugar de inicio. y &&x/2-1 = = lugar final ; gotoxy(x, y

Descanso

case Enter:if(y-2 == lugar inicial . y); & & ampx/2-1 == lugar de inicio (' # '); laberinto[y-2][x/2-1]= 0; gotoxy(x, y);

Pausa;

Página de inicio del caso: if( Maze[y-2][x/2-1]&&!b_start)

{

lugar de inicio. x = x/2-1;

lugar de inicio . y = y-2;

patch(' S '); );

b _ start = TRUE

}

Pausa;

Fin del caso: if(Laberinto[y-2] [x/2-1]& amp& b_end)

{

lugar final x = x/2-1

lugar final . >patch(' E ');

gotoxy(x, y);

b_end = TRUE

}

Romper ;

Caso Esc: gotoxy(2, 22); printf("salir"); dormir(1);

Caso F9: if (b_start & amp& ampb _ end)flag = TRUE;

Caso F2: caso gotoxy (Artículo 2, 22);

printf(" Savename:"); ("%s ",savename);

gotoxy(2,22);

if(Guardar laberinto(Guardar nombre))printf(" ¡Guardar OK! ");

else printf("¡Error al guardar!");

Dormir(1);

gotoxy

(2, 22);

printf(" ");

gotoxy(x, y);

Descanso; :romper

}

}

mientras(!flag);

for(I = 0;i<30;i++)

for(j = 0;j & lt20;j++)

{

Laberinto[j][i]. TD = Laberinto[j][I];

Laberinto[j][i]. marca = 0;

Laberinto[j][i]. pies = 0;

}

}

Estado LoadMaze(char *file)

/**/ /*El laberinto tiene cargado por completo. */

{

ARCHIVO * fp

char *buffer;

char ch

int i = 0, j, k;

Booleano len = FALSE, wid = FALSE

if ((fp = fopen(file, " r)) = = NULL)

Error de retorno;

buffer =(char *)malloc(600 * sizeof(char));

ch = fgetc(FP);

Y (ch! = EOF)

{

búfer[I] = ch

i++

ch = fgetc(FP ) ;

}

m = 30n = 20

for(I = 0;i<600;i++)

{

j = I/30; k = i % 30

if(buffer[I]= = ' 2 ' &&!len){ m = I;len = TRUE}

if(k = = 0 & &buffer[I]= = ' 2 ' & & &!wid){ n = j wid = TRUE}

Switch(buffer[i])

{

Caso "0": laberinto[j][k]= 0; descanso;

Caso ' 1 ': Laberinto [j] [k] = 1; Romper;

Caso ' 2 ': Laberinto [j] [k] = 2

Caso ' 3 ': laberinto [j] = 1; ;

lugar de inicio . x = k

lugar de inicio

b _ inicio = VERDADERO

Romper;

Caso '4': laberinto[j][k]= 1;

lugar final x = k;

lugar final y = j;

b _ end = TRUE

Romper

Predeterminado: romper

}

}

fclose(FP);

clr SCR();

para(I = 0;i<30;i++ )

para(j = 0 ;j & lt20;j++)

{

Laberinto[j][i]. TD = Laberinto[j][I];

Laberinto[j][i]. pies = 0;

Laberinto[j][i].

marca = 0;

if (Laberinto[j][i] == 0)

{

gotoxy(2*i + 2, j+2 );

patch(' # ');

}

}

gotoxy(2*StartPlace.x + 2, iniciar lugar . y+2);

patch(' S ');

gotoxy(2*EndPlace.x + 2, lugar final . y+2);

patch(' E ');

Regresar OK;

}

Laberinto para guardar estado (char *nombre de archivo)

/**/ /*El laberinto está guardado. */

{

ARCHIVO * fp

char *buffer;

int i, j, k;

fp = fopen(nombre de archivo, "WB");

buffer =(char *)malloc(600 * sizeof(char));

for(I = 0 ;i<600 ;i++)

{

j = I/30;k = i % 30

Interruptor (laberinto[j][k])

{

Caso 0: buffer[I]= ' 0 '; roto

caso 1: buffer[I]= ' 1 ';

Caso 2: buffer[I]= ' 2 '; roto;

Valor predeterminado: Error(" Escritura "); >}

p>

if(k == lugar de inicio. x & amp; & ampj = = lugar de finalización. y)buffer[I]= ' 4 '; >}

fwrite(búfer, 600, 1, FP);

} p>

Libre(búfer);

fclose(FP);

Regresar OK;

}

Error no válido (char *mensaje)

{

clr SCR( );

fprintf(stderr, "Error: %s\n ", mensaje);

Salir(1);

} /**/ / *Error*/

Estado de la pila de inicialización (stack*s)

/* */ /*La pila s se ha creado y se ha inicializado para vaciarla. */

{

s-& gt; base =(tipo selem *)malloc(STACK _ INIT _ TAMAÑO * sizeof(tipo selem)); >if(!s->base) error("overflow");

s->top = s->base;

s-> STACK _ INIT _ TAMAÑO

Regresar OK;

} /**/ /* InitStack */

Estado destruir pila (pila *s)

/**/ /*La pila s ha sido destruida.

*/

{

s-& gt;top = NULL

s->tamaño de pila = 0;

Gratis ( s->base);

s->base = NULL

Regresar OK;

} /**/ /* DestroyStack * /

Estado Borrar Pila (Stack)

/**/ /*La pila se ha borrado al máximo. */

{

s->top = s->base;

s->stacksize = STACK_INIT_SIZE

Return OK;

} /**/ /* ClearStack */

Atributo de pila booleano (pila *s)

/ **/ /*Compruebe si la pila s está vacía. */

{

si(s-& gt; top == s-& gt; base) devuelve VERDADERO

de lo contrario, devuelve FALSO

} /**/ /* StackEmpty */

int StackLength(Stack *s)

/**/ /*Obtiene la longitud de la pila, s. /

{

if(s->top>s->base)return(int)(s->top-s->base);

De lo contrario, devuelve 0;

} /**/ /* StackLength */

Inserción de estado (pila *s, seleccione tipo e)

/**/ /*El elemento e ha sido insertado en la pila s */

{

if(s-& gt; top-s-& gt; base >= s. ->tamaño de pila)

{

s->base = (tipo selem *)realloc(s->base,

(s- >tamaño de pila+incremento de pila)* tamaño de(tipo selem));

if (!s->base) error("overflow");

p>

s->top = s->base+s->tamaño de pila

s->tamaño de pila+= incremento de pila;

}

* s->; top++ = e;

Regresar OK;

} /**/ /*Push*/

SElemType Pop(pila *s, SElemType e)

/**/ /*El elemento e ha sido eliminado de la pila s*/

{

if(s->top == s->base) error("Pop");

e = *-s->top;

return e;

} /* */ /* Pop */

Estado GetTop(Stack *s, SElemType *e)

/**/ /* El elemento e ha alcanzado la parte superior de la pila s.* /

{

if(s-& gt; top == s-& gt; base) error (" GetTop "); *(s->;top-1);

Regresar OK;

} /**/ /* GetTop */

/**/ / *Atraviesa la pila usando la función "acceso".

*/

/* *//* Estado Recorrido de la pila(Pila * s, Estado (* visita)(SElemType *se))

{

Seleccionar p tipo;

int resultado;

if (s-& gt; top == s-& gt; base) devuelve un error

p = s ->base;

mientras (!(p==s->top))

{

resultado=(*acceso)( p );

p++;

}

Regresar OK;

} */

Pase booleano ( PosType curpos)

/**/ /*Comprueba si se puede pasar la posición actual. */

{

if (laberinto[curpos.x][curpos.y].td == 1. & amp

laberinto[curpos.x ][curpos.y].ft == 0&&maze[curpos.x][curpos.y].

Devuelve VERDADERO

En caso contrario, devuelve FALSO. /**/ /*Pase*/

Impresión de marcas no válidas (asientos traseros)

/**/ /*Marcar posición del asiento. */

{

Laberinto[seat.x][seat.y]. mark =-1;

/**/ /*La marca '-1' significa que no se puede colocar la posición actual. */

} /**/ /* MarkPrint */

Huella vacía (PosType curpos)

/**/ /*El fondo del laberinto El vértice se ha establecido en "verdadero". */

{

Laberinto[curpos.x][curpos.y]. Pies = 1;

} /**/ /*huella*/

NextPos trasero (asiento trasero, int di)

{< / p>

Cambiar (di)

{

caso 1:asiento y++; volver asiento /**/ /*hacia el este*/

Caso 2: asiento x++; retorno asiento; /**/ /*sur*/

Caso 3: retorno asiento /**/ /*oeste*/< /p. >

Caso 4: asiento x-; regresar asiento; /**/ /*Hacia el norte*/

Valor predeterminado: asiento x = 0; /p>

}

} /**/ /* NextPos */

/**/ /*Clave del programa. */

/**/ /* Pre: Matriz de laberinto y punto de inicio del amplificador y punto final del amplificador.

Publicar: Encuentra un recorrido del laberinto y ejecuta el camino del laberinto.

Propósito: clase de pila ADT.

*/

Estado MazePath (inicio después de la entrada, fin después de la entrada)

{

Cupos tipo post

int curstep

Seleccione el tipo;

Apilar *s, apilar;

STACK base =(selem type *)malloc(STACK _ INIT. _ TAMAÑO * tamaño de (tipo selem));

if (!stack.base) error ("desbordamiento");

pila superior = base .

PILA . TAMAÑO DE PILA = PILA _ INIT _ TAMAÑO;

s = & pila

curpos = inicio

curstep = 1; p>

p>

Hacer

{

si (Pasa(curpos))

{

Huella ( curpos);

e.ord = curstepe.seat = curpose di = 1;

gotoxy((curpos.y + 1)*2, curpos . x+2. );

patch(' @ ');

Retraso (8000); /**/ /* posponer tiempo. */

Push (s, e);

if(curpos . x == end . x & amp; & ampcurpos.y == end.y) /**/ /*Continuar recursivamente. */

{

Destruye la pila;

Devuelve TRUE

}

curpos = NextPos(curpos , 1); /**/ /* Prueba la siguiente posición. */

paso cur++;

}

Otros

{

if (! parte superior de la pila)

{

e = Pop(s, e);/**/ /*Eliminar e de s */

while(e . di = = 4 &&! StackEmpty(s)) /**/ /*Se han comprobado cuatro direcciones

y s no está vacía. */

{

mark print(e . asiento);

gotoxy((e.seat.y + 1)*2, e . asiento . x+2);

patch(' @ ');

Retraso (8000); /**/ /* Posponer tiempo. */

gotoxy((e.seat.y + 1)*2, e . asiento . x+2

patch('); >e = Pop(s, e);/**/ /*Eliminar e de s */

curstep-;

}

if ( e. di<4) /**/ /*La posición actual aún no ha sido comprobada. */

{

e . di++;

Empujar (s, e); /**/ /*Insertar e en */

curpos = NextPos(e. asiento, e. di); /**/ /* Prueba la siguiente posición.

*/

}

}

}

}

Y (!StackEmpty(s));

Destruye la pila;

Devuelve FALSE

} /**/ /* MazePath */

void main()

{

PosType inicio, fin;

creat maze();

inicio x = lugar de inicio y;

inicio .y = lugar inicial x .

final x = lugar final . > if (MazePath(inicio, fin))

{

gotoxy(2, 22);

printf("Ruta encontrada\ n ");

gotoxi(2, 22); p>

}

Otro

{

gotoxi(2, 22);

printf("Ruta no encontrada \ n ");

}

getch();

clr SCR(); p>

}

Lo encontré en línea. ¿Cómo usarlo? Vea usted mismo.