Um simples código para fins didáticos de controle aéreo utilizando filas.

• Download aeroporto.c
• Enviar nova versão

Esconder código-fonte

#include <stdio.h>

#include <stdlib.h>

#define max 10



#pragma region Protótipos e estruturas da Pilha

typedef struct Celula_Str *Apontador;

typedef int TipoChave;



typedef struct TipoItem {

   TipoChave Chave;

} TipoItem;



typedef struct Celula_Str {

   TipoItem Item;

   Apontador Prox;

} Celula;



typedef struct TipoFila {

   Apontador Frente, Tras;

} TipoFila;



void FfVazia (TipoFila *);

bool Vazia (TipoFila);

bool Enfileira (TipoItem, TipoFila *);

void imprimir (TipoFila);

bool Desenfileira (TipoItem *, TipoFila *);

bool ListaFila(TipoFila);

#pragma endregion



#pragma region Protótipos do programa

int menu();

int ListaPista(int *);

int LiberaPista(int *);

int VerificaHangar(int *);

bool Pousar(int *, int);

int ListaHangar(int *);

int Decolar(int *, int);

int BuscaHangar(int, int *);



#pragma endregion



int main() {

   int opcao, aviao, numero, check;

   int pista[3] = { 0 };

   int hangar[max] = { 0 };

   char op;

   TipoItem itemEsperaDecolagem;

   TipoItem itemEsperaPouso;

   TipoFila filaEsperaDecolagem;

   TipoFila filaEsperaPouso;

   FfVazia(&filaEsperaDecolagem);

   FfVazia(&filaEsperaPouso);

   do {

      system("cls");

      opcao = menu();

         switch (opcao) {

#pragma region Opções de Chegada do aviao

            case 1 : //Solicitar autorização para pouso

            check = ListaPista(pista);

               if (check < 0) {

                  printf("Digite o numero do aviao para solicitacao de pouso : ");

                  scanf("%d", &aviao);                        

                  printf("\nTodas as pistas estao ocupadas neste momento, adicionando aviao %d a espera para pouso\n", aviao);

                  itemEsperaPouso.Chave = aviao;

                     if (Enfileira(itemEsperaPouso, &filaEsperaPouso))

                        printf("Aviao %d inserido na fila de espera com sucesso!\n", itemEsperaPouso.Chave);

               }

               else

                  printf("Existem %d pistas liberadas para pouso!\n", check);

            break;

            case 2 : //Liberar pista para pouso

               do {

                  check = ListaPista(pista);

                     if ( check > 0) {

                        printf("Aviao na fila de espera para pouso?(s/n) ");

                        fflush(stdin);

                        op = getchar();

                           if (op == 's') {

                              if (Desenfileira(&itemEsperaPouso, &filaEsperaPouso))

                                 printf("%d Pistas liberadas para pouso!\nPouso do aviao %d liberado!\n", check, itemEsperaPouso.Chave);

                              if (Pousar(pista, itemEsperaPouso.Chave))

                                            printf("Aviao %d em pouso\n", itemEsperaPouso.Chave);

                                    }    

                           else {

                              printf("Digite o numero do aviao a pousar: ");

                              scanf("%d",&aviao);

                                 if (Pousar(pista, aviao))

                                    printf("Aviao %d em pouso\n", aviao);

                           }

                     }

                     else 

                        printf("Pistas cheias, execute a solicitacao primeiro!\n");         

                    printf("Deseja pousar outro aviao?(s/n)");

                    fflush(stdin);

               op = getchar();

               system("cls");

               } while (op != 'n');    

            break;

            case 3 :  //Finalizar pouso e colocar avião no Hangar

            check = (VerificaHangar(hangar)); //Verifica uma posição livre no hangar

                  if (check >= 0) {

                     numero = LiberaPista(pista);

                     hangar[check] = pista[numero];

                     pista[numero] = 0;

                  }       

                  else

                     printf("Hangar Cheio!\nO Aviao sera destruido!\n");

            break;

#pragma endregion

#pragma region Opções de Saída do avião            

            case 4 : //Inserir na fila para Decolagem

                check = ListaPista(pista);

            ListaHangar(hangar);                        

            printf("Digite o numero do Aviao para solicitacao de decolagem : ");

            scanf("%d", &aviao);

            numero = BuscaHangar(aviao, hangar);

               if (numero >= 0) {

                  printf("Hangar %d liberado\n", numero+1);

                  hangar[numero] = 0;

                  printf("Adicionando aviao %d a espera para decolagem\n", aviao);

                  itemEsperaDecolagem.Chave = aviao;

                     if (Enfileira(itemEsperaDecolagem, &filaEsperaDecolagem))

                        printf("Aviao %d inserido na fila de espera com sucesso!\n", itemEsperaDecolagem.Chave);

                    }

            printf("Existem %d pistas liberadas para decolagem nesse momento\n", check);    

            break;

            case 5 : //Inserir na Pista para decolagem

            check = ListaPista(pista);                    

               do {

                  if (Vazia(filaEsperaDecolagem))

                     printf("Nao existem avioes na fila para decolagem\n");    

                  else {

                     if (check > 0) {

                        if (Desenfileira(&itemEsperaDecolagem, &filaEsperaDecolagem))

                           printf("%d Pistas liberadas para decolagem!\nDecolagem do aviao %d liberada!\n", check, itemEsperaDecolagem.Chave);

                        check = Decolar(pista, itemEsperaDecolagem.Chave);

                        if (check > 0)

                           printf("Aviao %d Decolando na Pista %d\n", itemEsperaDecolagem.Chave, check);

                     }

                     else

                        printf("Todas as pistas estao ocupadas!\n");            

                  }                        

               printf("Deseja Inserir outro aviao na pista?(s/n)");

               fflush(stdin);

               scanf("%d", &op);

                    } while (op != 'n');    

            break;

            case 6 : //Finalizar decolagem

                check =  LiberaPista(pista);

               if (check >= 0)

                  pista[check] = 0;

            break;

         }//Fim do Switch Case

#pragma endregion

         system("pause");

         system("cls");

         fflush(stdin);

         check = ListaPista(pista);

         printf("Avioes na espera para pouso : ");

         if (!ListaFila(filaEsperaPouso))    

            printf("\nNao existem avioes na espera para pouso\n");

         printf("Avioes na espera para Decolagem : ");

         if (!ListaFila(filaEsperaDecolagem))    

            printf("\nNao existem avioes na espera para decolagem\n");

         system("pause");

   } while (opcao != 7);





return 0;

}



#pragma region Funções Fila

void FfVazia (TipoFila *Fila) {

    Fila->Frente = (Apontador) malloc(sizeof(Celula));

    Fila->Tras = Fila->Frente;

    Fila->Frente->Prox = NULL;

}



bool Vazia (TipoFila Fila) {

    return (Fila.Frente == Fila.Tras);

}



bool Enfileira(TipoItem Item, TipoFila *Fila) {

    Fila->Tras->Prox = (Apontador) malloc(sizeof(Celula));

    Fila->Tras = Fila->Tras->Prox;

    Fila->Tras->Item = Item;

    Fila->Tras->Prox = NULL;

return true;    

}



bool Desenfileira (TipoItem *Item, TipoFila *Fila) {

    Apontador q;

        if (Vazia(*Fila)) {

            printf("Fila Vazia!\n");

            return false;

        }    

        else {

            q = Fila->Frente;

            Fila->Frente = Fila->Frente->Prox;

            *Item = Fila->Frente->Item;

            free(q);

        }

    return true;    

}



bool ListaFila(TipoFila X) {

    Apontador aux; // Apontador temporário para rodar a fila

    aux = X.Frente->Prox;

        if (Vazia(X))

            return false;

        else {    

            while (aux != NULL) {

                printf("%d\t", aux->Item.Chave);

                aux  = aux->Prox;

            }

        printf("\n");

        }

    return true;    

}

#pragma endregion



int menu () {

int opcao;

        printf(

            "\t\t\t#########################################\n"

            "\t\t\t#      SISTEMA DE CONTROLE AEREO        #\n"    

            "\t\t\t#########################################\n"

            "\t\t\t#_   1 . Solicitar pouso               _#\n"            

            "\t\t\t#_   2 . Inserir aviao para pouso      _#\n"         

            "\t\t\t#_   3 . Finalizar pouso               _#\n"

            "\t\t\t#_   4 . Solicitar decolagem           _#\n"

            "\t\t\t#_   5 . Inserir aviao para decolagem  _#\n"

            "\t\t\t#_   6 . Finalizar decolagem           _#\n"

            "\t\t\t#_   7 . Sair do programa              _#\n"    

            "\t\t\t#########################################\n"

            );

    scanf("%d", &opcao);

    return opcao;

}

#pragma region Entrada do avião

int ListaPista(int *pista) {

    int check[2] = {0};

    printf("PISTA\t\tAVIAO\n");

    for (int i = 0; i < 3; i++) {

        if (pista[i] == 0) {

            printf("Pista %d\t =>\t -\n", i+1);

            check[0]++;

            check[1] = i;

        }

        else

            printf("Pista %d\t =>\t %d\n", i+1, pista[i]);

    }

    if (check[0] == 3 || check[0] == 2 || check[0] == 1)

        return check[0];    //Quantidade de pistas vazias

    else

        return -1; //Pista Cheia

}



int LiberaPista(int *pista) {

   system("cls");

    int check = ListaPista(pista);

    int numero;

    bool verifica;

        if (check == 3) {

            printf("Nao existem avioes nas pistas!\nNao autorizado!\n");

            return -1;

        }    

        else {

            do {

                printf("Digite o numero da Pista para finalizar a atividade: ");

                scanf("%d", &numero);

            numero--;//Acertando o numero da pista com posição no vetor

                    if (pista[numero]) {

                        printf("Pista %d liberada com sucesso!\nAviao %d\n", numero+1, pista[numero]);            

                        return numero;

                    }    

                    else {

                        printf("Nao ha avioes na pista %d!\nEscolha outra pista!", numero);

                            verifica = false;    

                    }

            } while (verifica = false);            

        }

    return -1;    

}



bool Pousar(int *pista, int aviao) {

int numeroPista;

    printf("Digite o numero da Pista para pouso: ");

    scanf("%d", &numeroPista);

   numeroPista--; //Acertando o numero da pista com posição no vetor

        if (pista[numeroPista] != 0)

            printf("Pista %d ocupada, escolha outra acima\n", numeroPista);

        else        

            pista[numeroPista] = aviao;

    return true;

}

#pragma endregion

#pragma region Saída do avião

int VerificaHangar(int *hangar){

   for (int i = 0; i < max; i++){

        if (!hangar[i])

            return i;

    }

    return -1;

}



int ListaHangar(int *hangar) {

int i = 0, j = 0;

    printf("Avioes no Hangar : \nAviao\t\t\tHangar\n");

        while (i < max) {

            if (hangar[i] > 0) {

                printf("  %d\t\t\t  %d\n", hangar[i], i+1);

                j++;    

            }

            i++;

        }

        printf("Quantidade de Avioes no Hangar : %d\n", j);

    return j; //Retorna a quantidade de avioes no hangar

}



int Decolar(int *pista, int aviao) {

int numeroPista;

    printf("Digite o numero da Pista para Decolagem: ");

    scanf("%d", &numeroPista);

   numeroPista--;//Acertando o numero da pista com posição no vetor

        if (pista[numeroPista] != 0) {

            printf("A pista ocupada, escolha outra acima\n");

            return -1;

        }    

        else

            pista[numeroPista] = aviao;    

    return numeroPista+1;

}



int BuscaHangar(int aviao, int *hangar) {

int i = 0;    

    while (i < max) {

        if (hangar[i] == aviao)

            return i;

    i++;    

    }

return -1;    

}

#pragma endregion

Ordenação Binaria

métodos de ordenação

Uso de threads no C

Potências de 2

Retorna o tempo ocioso em uma sessão do X