aeroporto

q2.c

//Equipe: Pablo AS Hugen
//Questão 02: Simulação de Filas
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define CLEARCMD "clear"

/*Id único para cada avição decolando*/
int id_decol;

/*Estrutura de um avião*/
typedef struct
{
	int id;
	int fuel;
}aviao;

/* Estruturas de nó e cabeçalho da listaDE/fila*/
typedef struct Lnode
{
	struct Lnode *Next;
	aviao Data;
	struct Lnode *Prev;
}Lnode;
typedef struct Lhead
{
	Lnode *First;
	int Lenght;
	Lnode *Last;
}Lhead;

/*Funções sobre  fila*/
void Linit(Lhead *l);
void Lfree(Lhead *l);
void Lprint(Lhead l);
Lnode *LnodePtr(Lhead *l, int index);
/* Remoção */
int LpopLeft(Lhead *l);
int LpopRight(Lhead *l);
int Lremove(Lhead *l, int index);
/*Remoção pela esquerda*/
aviao deQueue(Lhead *l);
/*inserção pela direita*/
int enQueue(Lhead *l, aviao Data);


/*funções sobre o aeroporto*/
/*Retorna o index da menor fila*/
int fila_menor(Lhead filas[4], int n);
/*Retorna o index da maior fila*/
int fila_maior(Lhead filas[4], int n);
/*Enfileira 'n_aviao' de aviões nas filas*/
void enfileira_decolando(int n_aviao);
/*Enfileira 'n_aviao' de aviões nas filas*/
void enfileira_aterrissando(int n_aviao);
/*Decide quais pistas vão usadas para aterrisagens ou decolagens*/
void aterrissa_decola();
/*Decrementa o combustível de todos os aviões nas filas de aterrissagem*/
void decrem_combust();
/*Se possível, Aterrissa aviões em condições emergenciais de combustível*/
void emergencia();
/*Printa as informações*/
void relatorio();
/*retorna o tempo médio ESTIMADO de decolagem/aterrissagem*/
float tempo_estimado(Lhead filas[4], int n);


/*Filas para aterissagem*/
Lhead fila_aterrissagem[4];
/*Fila para decolagem*/
Lhead fila_decolagem[3];
/*Flags usadas para a disponibilidade das pistas*/
int pistas_usadas[3];

int main()
{
	srand(time(NULL));
	
	
	/*Quantidade de aviões chegando, e decolando*/
	int chegando, decolando;
	
	/*inicia as filas*/
	Linit(&fila_aterrissagem[0]);
	Linit(&fila_aterrissagem[1]);
	Linit(&fila_aterrissagem[2]);
	Linit(&fila_aterrissagem[3]);
	Linit(&fila_decolagem[0]);
	Linit(&fila_decolagem[1]);
	Linit(&fila_decolagem[2]);

	while(1)
	{
		system(CLEARCMD);

		/*Nova unidade de tempo implica que as pistas voltam a ficarem disponíveis*/
		pistas_usadas[0] = pistas_usadas[1] = pistas_usadas[2] = 0;
		
		/*Número de aviões que chegaram nas filas de decolagem e aterrissagem
		 * aleatórios */
		decolando = rand()%4;
		chegando = rand()%4;
		
		/*enfileira os aviões chegando nas filas*/	
		enfileira_decolando(decolando);
		enfileira_aterrissando(chegando);
		
		/*Decrementa o combustível dos aviões nas filas de aterrissagem*/
		decrem_combust();
		
		/*Imprime o relatórios da situação das filas*/
		relatorio();
		
		/*Relatório emergencial, mostra quais aviões estão com pouco combustível,
		 * e quais tem que aterrisar para não cair.Para esse último caso, tenta aterrisá-los
		 * em uma das 3 pistas, se disponíveis*/
		emergencia();

		/*Realiza uma aterrissagem OU decolagem nas pistas disponíveis*/
		aterrissa_decola();
		
		
		printf("\nPressione [ENTER] para avançar 1 unidade de tempo: ");
		getchar();

	}
		
}

void relatorio()
{
	printf("Filas de decolagem:\n\n");
	printf("\tPista 1:\n");
	Lprint(fila_decolagem[0]);
	printf("\tPista 2:\n");
	Lprint(fila_decolagem[1]);
	printf("\tPista 3:\n");
	Lprint(fila_decolagem[2]);
	printf("\n\tTempo médio ESTIMADO de decolagem: %.1f u.t.\n", tempo_estimado(fila_decolagem, 4));
	
	printf("\nFilas de aterrissagem:\n\n");
	printf("\tPista 1-1:\n");
	Lprint(fila_aterrissagem[0]);
	printf("\tPista 1-2:\n");
	Lprint(fila_aterrissagem[1]);
	printf("\tPista 2-1:\n");
	Lprint(fila_aterrissagem[2]);
	printf("\tPista 2-2:\n");
	Lprint(fila_aterrissagem[3]);
	printf("\n\tTempo médio ESTIMADO de aterrissagem: %.1f u.t.\n", tempo_estimado(fila_aterrissagem, 3));

}

void Linit(Lhead *l)
{
	l->First = l->Last = NULL;
	l->Lenght = 0;
}

void Lfree(Lhead *l)
{
	Lnode *aux = l->First;

	while(aux)
	{
		/* Desacopla o primeiro nó */
		l->First = l->First->Next;
		if(l->First)
			l->First->Prev = NULL;

		/* Desaloca o primeiro nó e vai para o próximo */
		free(aux);
		aux = l->First;
	}
	Linit(l);
}

void Lprint(Lhead l)
{
	Lnode *aux;

	aux = l.First;
	while(aux)
	{
		printf("%s%d@%d%s",(aux==l.First)?("\t["):(""),
				aux->Data.id,
				aux->Data.fuel,
				(aux->Next==NULL)?("]\n"):(", "));
		aux = aux->Next;
	}
}

int enQueue(Lhead *l, aviao Data)
{
	Lnode *no = (Lnode *)malloc(sizeof(Lnode));

	/* Se a alocação Falhou */
	if(no == NULL)
		return 1;


	// Faz o nó apontar para seus vizinhos
	no->Prev = l->Last;
	no->Data = Data;
	no->Next = NULL;

	/* Faz os vizinhos apontarem para o nó,
	 * trata o caso da lista vazia */
	if(l->First == NULL)
		l->First = no;
	else
		l->Last->Next = no;

	l->Last = no;
	l->Lenght++;

	return 0;
}

aviao deQueue(Lhead *l)
{
	Lnode *aux = l->First;
	aviao ret = l->First->Data;

	/* A lista tem só um elemento */
	if(l->First == l->Last)
		l->First=l->Last = NULL;
	else
	{
		l->First->Next->Prev = NULL;
		l->First = l->First->Next;
	}

	l->Lenght--;
	free(aux);
	return ret;
}

int fila_menor(Lhead filas[4], int n)
{
	int menor_index = 0;
	int menor_val = filas[0].Lenght;
	int i;
	
	for(i=1; i<n; i++)
	{
		if(filas[i].Lenght<menor_val)
		{
			menor_val = filas[i].Lenght;
			menor_index = i;
		}
	}
	return menor_index;
}

int fila_maior(Lhead filas[4], int n)
{
	int maior_index = 0;
	int maior_val = filas[0].Lenght;
	int i;
	
	for(i=1; i<n; i++)
	{
		if(filas[i].Lenght>maior_val)
		{
			maior_val = filas[i].Lenght;
			maior_index = i;
		}
	}
	return maior_index;
}

void enfileira_decolando(int n_aviao)
{
	aviao av[3];
	int i;
	for(i=0; i<n_aviao; i++)
	{
		av[i].id = ++id_decol;
		av[i].fuel = 20;
		enQueue(&fila_decolagem[fila_menor(fila_decolagem, 3)], av[i]);
	}
}

void enfileira_aterrissando(int n_aviao)
{
	aviao av[3];
	int i;
	for(i=0; i<n_aviao; i++)
	{
		av[i].id = ++id_decol;
		av[i].fuel = (rand()%20)+1;
		enQueue(&fila_aterrissagem[fila_menor(fila_aterrissagem, 4)], av[i]);
	}
}


void decrem_combust()
{
	int i;
	Lnode *aux;
	for(i=0; i<4; i++)
	{
		aux = fila_aterrissagem[i].First;
		while(aux)
		{
			if(aux->Data.fuel)
				aux->Data.fuel--;

			aux = aux->Next;
		}
	}
}

void emergencia()
{
	int i,j;
	
	printf("\nRelatórios de Aterrissagens de emergência:\n\n");

	Lnode *aux;
	for(i=0; i<4; i++)
	{
		aux = fila_aterrissagem[i].First;
		for(j=0; aux && j<fila_aterrissagem[i].Lenght; j++, aux= aux->Next)
		{
			if(aux->Data.fuel == 2)
				printf("\tAvião %d com pouco combustível, aterrissagem emergencial será relizada em breve!\n\n", aux->Data.id);
			
			if(aux->Data.fuel == 1)
			{
				printf("\tAvião %d em situação crítica de combustível!\n", aux->Data.id);
				if(!pistas_usadas[2])
				{
					printf("\tPista 3 Disponível, realizando pouso de emergência!\n\n");
					pistas_usadas[2] = 1;
					Lremove(&fila_aterrissagem[i], j);
				}
				else if(!pistas_usadas[1])
				{
					printf("\tPista 2 Disponível, realizando pouso de emergência!\n\n");
					pistas_usadas[1] = 1;
					Lremove(&fila_aterrissagem[i], j);
				}
				else if(!pistas_usadas[0])
				{
					printf("\tPista 1 Disponível, realizando pouso de emergência!\n\n");
					pistas_usadas[0] = 1;
					Lremove(&fila_aterrissagem[i], j);
				}
				else
				{
					printf("\tNenhuma Pista disponível para aterrissagem, o avião caiu e foram contabilizadas %d mortes\n\n",(rand()%300)+100);
					Lremove(&fila_aterrissagem[i], j);
				}
			}
		}
	}
}

int LpopLeft(Lhead *l)
{
	Lnode *aux = l->First;

	/* A lista tem só um elemento */
	if(l->First == l->Last)
		l->First=l->Last = NULL;
	else
	{
		l->First->Next->Prev = NULL;
		l->First = l->First->Next;
	}

	l->Lenght--;
	free(aux);

	return 0;

}
int LpopRight(Lhead *l)
{
	Lnode *aux = l->Last;

	/* A lista tem só um elemento */
	if(l->First == l->Last)
		l->First=l->Last = NULL;
	else
	{
		l->Last->Prev->Next = NULL;
		l->Last = l->Last->Prev;
	}

	l->Lenght--;
	free(aux);

	return 0;

}
int Lremove(Lhead *l, int index)
{
	/* Erros de limites */
	if(index<0 || index>=l->Lenght)
		return(1);

	Lnode *aux = LnodePtr(l, index);


	/* Casos de remoçãoo nas extremidades */
	if(index == 0)
	{
		LpopLeft(l);
		return(0);

	}
	else if(index == l->Lenght-1)
	{
		LpopRight(l);
		return(0);

	}
	
	// 'Desacopla' o nó
	aux->Prev->Next = aux->Next;
	aux->Next->Prev = aux->Prev;

	l->Lenght--;
	free(aux);

	return(0);
}

Lnode *LnodePtr(Lhead *l, int index)
{
	Lnode *aux = l->First;
	for(int i=0; i<index && aux; i++, aux=aux->Next);
	return(aux);
}

void aterrissa_decola()
{
	/*Booleano aleatório que decidirá se uma pista será usada 
	 * para aterrissagem ou decolagem, 0 será ATERRISSAGEM e 1 DECOLAGEM*/
	int rnd;
	int i;

	printf("Relatório de aterrissagens e decolagens comuns:\n\n");
	for(i=0; i<3; i++)
	{
		/*Se a pista estiver disponível*/
		if(!pistas_usadas[i])
		{
			rnd = rand()%2;
			/*será usada para DECOLAGEM*/
			if(rnd)
			{
				/*Decola o 1° avião da fila de decolagem da pista 'i'*/
				/*Se a fila daquela pista conter algum avião*/
				if(fila_decolagem[i].First)
				{
					printf("\tAvião %d decolando na pista %d\n", deQueue(&fila_decolagem[i]).id, i+1);
					pistas_usadas[i]= 1;
				}
				/*Se não conter realiza um pouso, se a fila de aterrissagem daquela pista conter alguém*/
				else
				{
					if(i == 0)
					{
						/*Aterrissa o 1° avião da maior fila de aterrissagem da pista '1'*/
						/*Se tiver algum alvião nas filas de aterrissagem da pista 1*/
						if(fila_aterrissagem[i].First || fila_aterrissagem[i+1].First)
						{
							printf("\tAvião %d aterrissando na pista %d\n",deQueue(&fila_aterrissagem[fila_maior(fila_aterrissagem, 2)]).id, i+1);
							pistas_usadas[i]= 1;
						}
					}
					else if(i == 1)
					{
						/*Aterrissa o 1° avião da maior fila de aterrissagem da pista 2*/
						/*Se tiver algum alvião nas filas de aterrissagem da pista 2*/
						if(fila_aterrissagem[i+1].First || fila_aterrissagem[i+2].First)
						{
							printf("\tAvião %d aterrissando na pista %d\n",deQueue(&fila_aterrissagem[fila_maior(fila_aterrissagem+2, 2)]).id, i+1);
							pistas_usadas[i]= 1;
						}
					}
				}
			}
			/*Será usada para ATERRISSAGEM*/
			else
			{
				if(i == 0)
				{
					/*Aterrissa o 1° avião da maior fila de aterrissagem da pista '1'*/
					/*Se tiver algum alvião nas filas de aterrissagem da pista 1*/
					if(fila_aterrissagem[0].First || fila_aterrissagem[1].First)
					{
						printf("\tAvião %d aterrissando na pista %d\n",deQueue(&fila_aterrissagem[fila_maior(fila_aterrissagem, 2)]).id, i+1);
						pistas_usadas[i]= 1;
					}
					/*Se não houver realiza uma decolagem*/
					else if(fila_decolagem[i].First)
					{
						printf("\tAvião %d decolando na pista %d\n", deQueue(&fila_decolagem[i]).id, i+1);
						pistas_usadas[i]= 1;
					}
				}
				else if(i == 1)
				{
					/*Aterrisa o 1° avião da maior fila de aterrissagem da pista 2*/
					/*Se tiver algum alvião nas filas de aterrissagem da pista 2*/
					if(fila_aterrissagem[2].First || fila_aterrissagem[3].First)
					{
						printf("\tAvião %d aterrissando na pista %d\n",deQueue(&fila_aterrissagem[fila_maior(fila_aterrissagem+2, 2)]).id, i+1);
						pistas_usadas[i]= 1;
					}
					/*Se não houver realiza uma decolagem*/
					else if(fila_decolagem[i].First)
					{
						printf("\tAvião %d decolando na pista %d\n", deQueue(&fila_decolagem[i]).id, i+1);
						pistas_usadas[i]= 1;
					}
				}
			}
		}
	}
}

float tempo_estimado(Lhead filas[4], int n)
{
	/*Quantidade de aviões, e somatório dos tempos ESTIMADOS*/
	float qnt=0, soma=0;
	int i,j;
	for(i=0;i<n; i++)
	{
		qnt+=filas[i].Lenght;
		for(j=1; j<=filas[i].Lenght; j++)
			soma+=j;
	}
	if(qnt)
		return soma/qnt;
	else
		return 0;
}