Algoritmos y estructuras de datos de gestión de aparcamientos en lenguaje C

Estructura de datos en lenguaje C: Mi opinión sobre la gestión de flotas:

Hay tres estados del automóvil, representados por la declaración de cambio {

1: ¿Parar? A

El garaje no está lleno. Estacione en el garaje.

El almacén está lleno, estacionado en la acera

2: ¿Bajar? D

Salga del garaje y utilice el garaje temporal.

Abandone el camino de entrada y tome la acera temporal.

3: ¿Dejar de escribir? E

}

Nota:

1: ¿No omita el siguiente código? Recuerde al escribir "posición no calculada" que olvidó eliminarlo al cargarlo.

2. ¿Utilizar una matriz estática para registrar el tiempo de entrada y el uso? Número de matrícula

3: ¿Usar I estática para grabar los coches que entran y salen del garaje?

¿Subir al coche? i++

¿Conducir un coche?

4. Al escribir la parte más crítica, la definí después de usarla, por lo que se ve muy desordenada, incluido ha-_-_-

2. //Estoy usando VS2013.

#¿Incluir? & ltstdlib.h & gt

# include & ltstdio.h & gt

# include & ltiostream & gt

¿Usar? ¿Espacio de nombres? std

¿Electricidad estática? int? ¿I? =?1;

¿Electricidad estática? int? a[100];

#¿Definición? ¿STACK_INITSIZE? 100

#Definición? ¿Incremento de pila? 10

¿#Definición? OK1

#¿Definición? Error 0

//Estructura...................................... .. ....................................

typedef? estructura? Garaje {//Crea la estructura del garaje.

int? *Base;

int? * arriba

int? tamaño de pila

int? OutTime

}Garaje;

typedef? estructura? TPGarage{//Crea una estructura de garaje temporal.

int? *Base;

int? * arriba

int? tamaño de pila

} TpGarage

typedef? estructura? QNodo{

int? Fecha;

estructura? QNodo? *Siguiente;

}QNode,? * QueuePtr

typedef? Struct{//Crea la estructura de la acera.

¿PtrCola? Positivo;

QueuePtr? Trasero;

} OtGarage

typedef? estructura? TNode{//Crea una estructura de acceso temporal.

int? Tdate

estructura? ¿Nodo T? * Tsiguiente

}TNodo,? * TQueuePtr

typedef? Estructura {

TQueuePtr? Tfront

TQueuePtr? Trear

}TOtGarage

//............................. .. ......................Estructura organizacional............

/ /..... ......................................declaración..... ...... ...

¿Anulado? InitGarage(garaje?&s,?int?t); //Garaje

¿No válido? PushGarage(garaje?&s,?int?chp,?int?t);

¿Nulo? ZPushGarage(garaje?&s,?int?chp);

¿Nulo? GetTopGarage(TOtGarage?&TG,?OtGarage?&OG,?TpGarage?&t,?garage?&s,?int?chp,?int?t);

int? Pop(garaje?&s,?int?&GH);

¿Vacío? InitTpStack(TpGarage?&t); //Garaje temporal

¿No es válido? PushTpStack(TpGarage?&t,?int?chp);

¿No es válido? PopTpStack(TpGarage?&t,?int&chp);

¿No válido? InitOtGarage(OtGarage?& ampOG); //Cambiar carril

¿No es válido? PushTpStack(TpGarage?&t,?int?chp);

int? OutOtGarage(OtGarage?&OG,?int?&e);

¿No válido? InitTOtGarage(TOtGarage?& ampTG); //Canal temporal

¿No válido? TEnOtGarage(TOtGarage?&TG,?int?&te);

int? TOutOtGarage(TOtGarage?&TG,?int?&te);

int? transversal(garaje?s,?int?t); //Atravesar el garaje

int? push(char?x, ?int?chp, ?int?t, ?garage?&s, ?TpGarage?&t, ?OtGarage?&OG, ?TOtGarage?&TG); // hub

//. .......................................¿Declaración? ................................................

//.. .................................garaje....... ......... ....................................

¿Anulado? InitGarage(garage?&s,?int?T){//Problema de inicialización.

¿Tamaño de pila? =?t;

¿Base estadounidense? =?(int?*)malloc(s . tamaño de pila * sizeof(int));

S.top? =?Base de EE. UU.;

}

¿No es válido? PushGarage(garage?&s,?int?chp,?int?T){//Entra al garaje.

¿Centro para la Protección de la Salud? =?t;? //Registrar la hora actual

*(S.top)++? =?chp

}

¿Anulado? ZPushGarage(garage?&s,?int?Chp){//Ingresa el auto en el garaje.

*(S.arriba)? =?chp

s . top++;

}

¿No es válido? GetTopGarage(TOtGarage?&TG,?OtGarage?&OG,?TpGarage?&t,?garage?&s,?int?chp,?int?T){//Salir del garaje

int? ¿guardar? =?chp//Guardar la matrícula actual.

int? ¿puaj? =?0;

int? número

int? ¿fh? =?0;

int? ¿I? =?0;? //Recuerda el número de coches que salen del garaje.

int? ¿mi? =?0;//Realice un recorrido para encontrar la posición del automóvil.

int? js? =?0;

int? ¿Te? =?0;

¿Hora del descanso del sur? =?t;? // Si es así, bájate directamente y elimina el elemento.

¿Y si? (Lateral(S,Chp)){//Traverse. Si el coche está en el garaje, sal del garaje.

¿Cuándo? (Pop(S,gh)?!=?Hold){//Deja que el auto salga del garaje.

PushTpStack(T, GH);

i++;

}

¿Si? (num?=?(S.OutTime?-?a[chp])?%?10?==?0){

num? =?¿Tiempo de pausa? -?[chp];

}

¿Y si? número? =?((S.OutTime?-?a[chp])?/?10?+?1)?*?10;

cout? <<? "¿A qué hora está el coche en el aparcamiento"? <<? número? & lt& lt // Muestra la información del automóvil en este momento.

"Minutos, ¿cuál se cobra?" <<? 0,5*número? <<? "Yuan"? <<? endl

¿Para qué? (size_t?j?=?0;?j?<?i;?j++){

PopTpStack(T, FH);//Haga retroceder a otros por turno, avance una posición y El estacionamiento El espacio frente a la puerta está vacío.

ZPushGarage(S, FH);

}

¿Si? (OutOtGarage(OG,e))? {//Hay un coche al cambiar de carril y otro coche entra desde fuera.

PushGarage(S, e,? Tiempo de salida de EE. UU.);

}

}

Else{//Céntrate en el primero. uno ? Si aquí está el else correspondiente, significa que el automóvil saldrá de la acera temporal.

//Envía el coche de la acera a la acera temporal.

int? ¿y? =?OutOtGarage(OG,GH);

¿Cuándo? (gh?!=?mantener)? {//¿Dejar salir el coche del garaje? OutOtGarage(OtGarage?&OG,?int?&e)

TEnOtGarage(TG,?GH);? //Empujar al carril temporal

js++;

y? =?OutOtGarage(OG,GH);

}

¿Si? (js?==?0){?//El coche de atrás avanza.

//Simplemente sal del estacionamiento

¿cout? & lt& lt"Si el coche no está aparcado en el garaje, no tienes que pagar"? <<? endl

}

¿Y si? ¿si? (!OutOtGarage(OG, E)){//Si es el final en este momento, vuelva a ingresar al cambio de carril.

¿Para qué? (size_t?j?=?0;?j?<?i;?j++){

int? Cinco;

v? =?TOutOtGarage(TG,?te);? //

PushTpStack(T, te);? //La posición aún no ha sido calculada.

} I-;

¿cout? <<? ¿"Si el coche no está aparcado en el garaje no tienes que pagar"? <<? endl

}

¿Y si? {

¿cout? <<? ¿"Si el coche no está aparcado en el garaje no tienes que pagar"? <<? endl

int? JD;

¿QueuePtr? pag;? //Si hay un coche al cambiar de carril, devuelve otro coche.

p? =?og . frente-& gt; siguiente; =?p->Fecha;

og . frente->Siguiente? =?p->;Siguiente;

¿Y si? (OG.trasero?==?p)

OG.trasero? =?OG.front

Gratis (p);

//Libera un nodo primero y continúa la transmisión.

¿Cuándo? (OutOtGarage(OG,Gh)){//¿Dejar salir el coche del garaje? OutOtGarage(OtGarage?&OG,?int?&e)

TEnOtGarage(TG,?GH);? //Ir al carril temporal

}

¿Cuándo? (TOutOtGarage(TG,?Te)){

PushTpStack(T, te);

} I-;

}//Si no hay fondo en este momento, continúe hasta la vía de acceso temporal y luego cambie de carril.

}

}

int? Pop(garaje?&s,?int?&GH){? //Bajando del coche en el garaje

GH? =?*-s . arriba;

¿Volver? GH;

}

//................................. .. ...Garaje........................

//..... ........ ..........garaje temporal........................

¿No válido? InitTpStack(TpGarage?& ampT){//Inicializa el garaje temporal.

¿T.tamaño de pila? =?STACK _ INITSIZE

T.base? =?(int?*)malloc(t . tamaño de pila * tamaño de(int));

T.top? =?t . base;

}

¿No es válido? PushTpStack(TpGarage?&t,?int?chp){

Si? (T.top?-?T.base?& gt=?T.stacksize){

T.base? =?(int?*)realloc(T.base,

(T.stacksize?+?STACK _ INITSIZE)* sizeof(int));

T.top? =?T.base? +?T.stacksize

T.stacksize? +=?STACK _ INITSIZE

}

*T.top++? =?chp

}

¿Anulado? PopTpStack(TpGarage?&t,?int&chp){? // Cuando el valor de retorno es 1, elimina la parte superior de la pila y regresa.

chp? =?*-t .top;

}

//...................... ..Temporal garaje........................

//.... ............ .............cambió de carril. .................................

¿Anulado? InitOtGarage(OtGarage?& ampOG){//Canal de inicialización

OG.front? =?OG.¿Trasero? =?(queue ptr)malloc(sizeof(q node));

og front-& gt;¿Siguiente? =?NULL

}

¿No válido? EnOtGarage(OtGarage?& ampOG,?int?& ampE){//Entra para cambiar de carril.

¿PtrCola? p;

p? =?(queue ptr)malloc(sizeof(q node)); //Se utiliza para colocar el número de matrícula.

p->; =?e;

p->;¿Siguiente? =?NULL

og . trasero->Siguiente? =?p;

OG. =?p;

cout? <<? "El garaje está lleno. ¿Cuál es la primera parada en el cambio de carril?" <<? ¿I? <<? "?poco"? <<? endl

i++;

cout? <<? endl

}

int? OutOtGarage(OtGarage?&OG,?int?&E){//¿Cambiar de carril? Vehículo de despacho

cout? <<? endl//Si no hay coche, ¿volver? 0

¿Y si? (OG.front?==?Compartimento trasero){

¿Volver? Error;

}

QueuePtr? pag;? //Si hay un coche al cambiar de carril, devuelve otro coche.

p? =?og . frente-& gt; siguiente; =?p->Fecha;

og . frente->Siguiente? =?p->;Siguiente;

¿Y si? (OG.trasero?==?p)

OG.trasero? =?OG.front

Gratis(p);

Yo-;

¿Devolver? OK;

}

¿Nulo? InitTOtGarage(TOtGarage?& ampTG){//Canal de inicialización

TG. ¿Frente? =?TG. ¿Trear? =?(TQueuePtr)malloc(sizeof(TNode));

TG. tfront->Tsiguiente? =?NULL

}

¿No válido? TEnOtGarage(TOtGarage?& ampTG,?int?& ampTe){//Ingrese un cambio de carril temporal.

¿TQueuePtr? p;

p? =?(TQueuePtr)malloc(sizeof(TNode)); //Se utiliza para colocar el número de placa.

p->;¿Fecha? =?te;

p->;Tsiguiente? =?NULL

TG. trear->Tsiguiente? =?p;

TG. ¿Trear? =?p;

//cout? <<? "El garaje está lleno. ¿Cuál es la primera parada en el cambio de carril?" <<? ¿I? <<? "?poco"? <<? endl

i++;

cout? <<? endl

}

int? TOutOtGarage(TOtGarage?& ampTG,?int?& ampTe){//¿Cambio de carril temporal? Vehículo de despacho

cout? <<? endl//Si no hay coche, ¿volver? 0

¿Y si? (TG. Tfront?==?TG. Trear)

¿Regresar? Error;

TQueuePtr? pag;? //Si hay un coche durante el cambio temporal de carril, devuelve uno.

p? =?TG. tfront-& gt;Tnext

¿Te? =?p->;FechaT

TG. tfront->Tsiguiente? =?p->;Tsiguiente

¿Si? (TG. Trear?==?p)

TG. ¿Trear? =?TG. Tfront

Gratis(p);

Yo-;

¿Devolver? OK;

}

//................................ .. .......Vía de acceso temporal................................

/ /... .........................Cubo universal................. ..... ....................

int? push(char?x,?int?chp,?int?t,?garage?&s,?TpGarage?&t,?OtGarage?&OG,?TOtGarage?&TG){

¿Alternar? (X){//Determinar si el coche está entrando o saliendo.

¿Caso? A':{//Situación A, entra al garaje

¿Y si? (¿S.top?-?Base de EE. UU.?& gt=?S.stacksize){

cout? <<? "Qué hora es"? <<? t? <<? "minuto,?"? <<? ¿"Número de matrícula"? <<? ¿chp? <<? ¿"Nuestro coche entra a la acera y espera un lugar para estacionar"? <<? endl

//El garaje está lleno y luego el coche sale a la acera.

EnOtGarage(OG, chp); //Llama a la función para ingresar al cambio de carril.

}

En caso contrario{

//cout? <<? "Cortejar"? <<? endl

PushGarage(S, chp,?t); //Entra al garaje

}

¿Regresar? OK;

}Agrietado;

¿Caso? D':{//Caso D, saliendo del garaje

GetTopGarage(TG,?OG,?t,?s,?chp,?t //1: Ir al garaje

¿Volver? OK;

}Agrietado;

¿Caso? E':{//Situación E, limpiar todos los vehículos.

¿Volver? Error;

}Roto;

}

}

int? transversal(garaje?s,?int?t){

¿Cuándo? (S.top?!=?Base de EE. UU.){

s .top-;

¿Y si? (t?==?*S.top)

¿Volver? OK;

}

¿Volver? Error;

}

int? principal(){

int? num

¿Carácter? x;

int? Hora;

int? chp

int? x;

¿Garaje? s;

¿TpGaraje? t;

¿OtGaraje? OG;

¿TOtGarage? TG;

¿cout? <<? "Recordatorio: este estacionamiento cobra 0,5 yuanes cada 10 minutos, y la parte que dura menos de 10 minutos se cobrará como 10 minutos". <<? endl

cout? <<? "Por favor, introduzca el número total de plazas de aparcamiento:?";

cin? >>? num

cout? <<? endl

InitGarage(S, num);

InitTpStack(T);

InitOtGarage(OG);

InitTOtGarage(TG) ;

¿cout? <<? "¿La señal de alto de entrada es (e?0?0)"?& lt& lt? endl

cout? <<? "¿Información del aparcamiento? (¿formato?:?(acción, número de matrícula, hora)?:"?& lt& lt?endl

do {

cout?& lt& lt?" ¿Ingrese la información del estacionamiento?"?& lt& lt?endl

cin?& gt& gt?x?& gt& gt?chp?& gt& gt?Time;

x?=? Push (X,?chp,?time,?s,?t,?OG,?TG);

}?¿Cuándo?

}