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?
}