2014/1 - PA - Arquivos: Exemplo em C++

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <time.h> 

using namespace std;

int main(int argc, char *argv[])
{
    // problema
    // entrada: um número inteiro digitado pelo usuário (N)
    // saída: gerar N números aleatórios e escrever estes
    // números em arquivo.
    
    int n;
    srand(time(NULL)); // inicializando o gerador de numeros aleatório
    
    cout << "Digite um numero inteiro: " << endl;    
    // 1) Ler do usuario o numero inteiro (N)
    cin >> n;

    // abrir o arquivo para escrita
    ofstream arquivo;
    arquivo.open("dados.txt");
    // testar se o arquivo foi aberto com sucesso ou nao
    if (!arquivo.is_open()){
      cout << "ERRO: nao foi possivel abrir o arquivo!" << endl;
      return EXIT_FAILURE;
    }
    int numero = 0;
    // 2) Para cada numero de 1 até N 
    for (int i = 0; i < n; i++){
      // 2.1) gerar o numero aleatório
      numero = rand() % 100;
      // 2.2) escrever o número em arquivo
      cout << i << " - Escrevendo o número " << numero << " no arquivo." << endl;
      arquivo << numero << endl;
    }
    arquivo.close();
    
    // parte 2: abrir o arquivo e calcular o seu tamanho em bytes e 
    // quantidade de números
    
    ifstream arq;
    arq.open("dados.txt");
    arq.seekg(0, ifstream::end);
    streampos tamanho = arq.tellg(); // obtendo o tamanho do arquivo
    cout << "Arquivo gerado: " << tamanho << " Bytes." << endl;
    arq.close();
    system("PAUSE");
    return EXIT_SUCCESS;
}

2013/2-AED-Exercício Para Casa 8/11/2013

#include <stdio.h>
#include <stdlib.h>
#include "tad-lista.h"

int main(int argc, char *argv[])
{
  TipoLista lista, pares, impares;
  TipoItem item;
  int i = 0;
  int a[] = {2,5,6,7,8,9,11,12,15,16,17};
  int tam = 11;
  int capacidade = 10;
 
  // 1) Criar a lista
  CriarLista(&lista, capacidade);
  CriarLista(&pares, capacidade);
  CriarLista(&impares, capacidade);
  // 2) Imprimir a lista
  ImprimirLista(lista);
  // 3) inserir os elementos
  for (i = 0; i < tam; i++)
  {   item.Chave = a[i];
      InserirLista(&lista, item);
      // 4) Imprimir a lista
      ImprimirLista(lista);
  }
  // 5) Pesquisar a lista
  item.Chave = 5;
  i = PesquisarLista(lista, item);
  printf("Resultado pesquisa %d: %d\n",
    item.Chave, i);
  item.Chave = 3;
  i = PesquisarLista(lista, item);
  printf("Resultado pesquisa %d: %d\n",
    item.Chave, i);
   
  // 6) Retirar alguns elementos da lista
  for (i = 0; i < capacidade; i++)
  {
      RetirarLista(&lista, &item);
      printf("Retirado da lista: %d\n",
         item.Chave);
     // 7) imprimir a lista
      ImprimirLista(lista);
      //8) testar se numero eh par ou impar
      if (item.Chave % 2 == 0)
      { InserirLista(&pares, item);
      } else {
        InserirLista(&impares, item);
      }
  }
  printf("Pares: \n");
  ImprimirLista(pares);
  printf("Impares: \n");
  ImprimirLista(impares);
 
  system("PAUSE");   
  return 0;
}

2013/2-AED-TAD Lista Programa Principal E TAD Lista H

// TAD LISTA

// Tipos de dados
typedef int TipoChave;

struct T_Item{
  TipoChave Chave;
};

typedef struct T_Item TipoItem;

typedef struct T_Celula * TipoApontador;

struct T_Celula{
  TipoItem Item;
  TipoApontador Prox;
};

typedef struct T_Celula TipoCelula;

struct T_Lista{
  int Tamanho;
  int Capacidade;
  TipoApontador Primeiro, Ultimo;
};

typedef struct T_Lista TipoLista;

// Cabeçalho das operações

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item);
// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item);
// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item);
// verificar se estah cheia
int ListaCheia(TipoLista Lista);
// verificar se estah vazia
int ListaVazia(TipoLista Lista);
// criar uma nova lista
void CriarLista(TipoLista * Lista, int capacidade);
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista);
// imprimir a lista
void ImprimirLista(TipoLista Lista);

// Implementação das operações

void CriarLista(TipoLista * Lista, int capacidade){
// 1) criar a celula cabeça
  Lista->Primeiro = (TipoApontador) malloc(
                             sizeof( TipoCelula));
// 2) atualizar os apontadores Prim. e Ult.
  Lista->Ultimo = Lista->Primeiro;
// 3) atualizar o tamanho (zero) e capacidade (parametro)
  Lista->Tamanho = 0;
  Lista->Capacidade = capacidade;
// 4) atualizar o apontador prox da celula cabeca
  Lista->Primeiro->Prox = NULL;
}

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item)
{
  //1 ) verificar se LISTA estah cheia
  if (ListaCheia(*Lista) == 1){
    printf("ERRO: lista cheia!\n");return;
  }
  //2 ) criar nova celula a partir da ultima celula
  Lista->Ultimo->Prox = (TipoApontador)
      malloc(sizeof(TipoCelula));
  //3 ) inserir a chave na celula
  Lista->Ultimo->Prox->Item = item;
  //4 ) atualizar apontadores (prim e ult.)
  Lista->Ultimo = Lista->Ultimo->Prox;
  Lista->Ultimo->Prox = NULL;
  //5 ) atualizar tamanho
  Lista->Tamanho++;
}

// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item)
{
  TipoApontador aux, q;
  //1) verificar se LISTA estah vazia
  if(ListaVazia(*Lista) == 1){
    printf("ERRO: lista vazia");return;
  }
  //2) guardar a celula anterior (aux)
  aux = Lista->Primeiro;
  //3) guardar a celula a ser removida (q)
  q = aux->Prox;
  //4) atualizar a celula anterior
  aux->Prox = q->Prox;
  //5) obter o item removido
  *item = q->Item;
  //6) liberar o espaco de memoria de q
  free(q);
  //7) decrementar tamanho
  Lista->Tamanho--;
}

// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item)
{
  TipoApontador aux;
  int i = 0;
  //1) verificar se LISTA estah vazia
  if (ListaVazia(Lista) == 1){
    printf("ERRO: lista vazia!\n");return;
  }
  //2) inicializar o apontador aux
  aux = Lista.Primeiro;
  //3) enquanto houver celula apos aux
  while (aux->Prox != NULL &&
     aux->Prox->Item.Chave != item.Chave){
  //3.1) se a chave que estiver na celula apos aux
  //     for igual a chave procurada
  //3.2) atualizar aux
    aux = aux->Prox;
    i++;
  }
  if (aux->Prox !=NULL){
    // achei
    printf("Elemento encontrado!\n");
  } else {
    // nao achei
    printf("Elemento NAO encontrado!\n");
    i = -1;
  }
  return i;
}

// verificar se estah cheia
int ListaCheia(TipoLista Lista){
  if (Lista.Tamanho == Lista.Capacidade)
  {  return 1; // lista cheia
  } else {
    return 0;  //lista nao cheia
  }
}
// verificar se estah vazia
int ListaVazia(TipoLista Lista)
{
  if (Lista.Primeiro == Lista.Ultimo)
  { return 1; // lista vazia
  } else {
    return 0; // lista nao vazia
  }
}
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista){
  return Lista.Tamanho;
}
// imprimir a lista
void ImprimirLista(TipoLista Lista)
{
  TipoApontador aux;
 
  printf("TAD Lista [%d/%d]\n",
     Lista.Tamanho, Lista.Capacidade);
  //1) verificar se LISTA estah vazia
  if (ListaVazia(Lista) == 1){
    printf("ERRO: lista vazia!\n");return;
  }
  //2) inicializar o apontador aux
  aux = Lista.Primeiro;
  printf(" [/]-> ");
  //3) enquanto houver celula apos aux
  while (aux->Prox != NULL){
  //3.2) atualizar aux
    printf("[%d]-> ", aux->Prox->Item.Chave);
    aux = aux->Prox;
  }
  printf("NULL\n\n");
}














#include <stdio.h>
#include <stdlib.h>
#include "tad-lista.h"

int main(int argc, char *argv[])
{
  TipoLista lista;
  TipoItem item;
  int i = 0;
  int a[] = {2, 5, 6, 7, 8, 9, 11};
  int tam = 7;
  int capacidade = 10;
 
  // 1) Criar a lista
  CriarLista(&lista, capacidade);
  // 2) Imprimir a lista
  ImprimirLista(lista);
  // 3) inserir os elementos
  for (i = 0; i < tam; i++)
  {   item.Chave = a[i];
      InserirLista(&lista, item);
      // 4) Imprimir a lista
      ImprimirLista(lista);
  }
  // 5) Pesquisar a lista
  item.Chave = 5;
  i = PesquisarLista(lista, item);
  printf("Resultado pesquisa %d: %d\n",
    item.Chave, i);
  item.Chave = 3;
  i = PesquisarLista(lista, item);
  printf("Resultado pesquisa %d: %d\n",
    item.Chave, i);
   
  // 6) Retirar alguns elementos da lista
  for (i = 0; i < tam; i++)
  {
      RetirarLista(&lista, &item);
      printf("Retirado da lista: %d\n",
         item.Chave);
     // 7) imprimir a lista
      ImprimirLista(lista);
  }
 
  system("PAUSE");   
  return 0;
}

2013/2-AED-TAD Lista Arquivo .H

// TAD LISTA

// Tipos de dados
typedef int TipoChave;

struct T_Item{
  TipoChave Chave;
};

typedef struct T_Item TipoItem;

typedef struct T_Celula * TipoApontador;

struct T_Celula{
  TipoItem Item;
  TipoApontador Prox;
};

typedef struct T_Celula TipoCelula;

struct T_Lista{
  int Tamanho;
  int Capacidade;
  TipoApontador Primeiro, Ultimo;
};

typedef struct T_Lista TipoLista;

// Cabeçalho das operações

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item);
// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item);
// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item);
// verificar se estah cheia
int ListaCheia(TipoLista Lista);
// verificar se estah vazia
int ListaVazia(TipoLista Lista);
// criar uma nova lista
void CriarLista(TipoLista * Lista, int capacidade);
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista);
// imprimir a lista
void ImprimirLista(TipoLista Lista);

// Implementação das operações

void CriarLista(TipoLista * Lista, int capacidade){
// 1) criar a celula cabeça
  Lista->Primeiro = (TipoApontador) malloc(
                             sizeof( TipoCelula));
// 2) atualizar os apontadores Prim. e Ult.
  Lista->Ultimo = Lista->Primeiro;
// 3) atualizar o tamanho (zero) e capacidade (parametro)
  Lista->Tamanho = 0;
  Lista->Capacidade = capacidade;
// 4) atualizar o apontador prox da celula cabeca
  Lista->Primeiro->Prox = NULL;
}

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item)
{
  //1 ) verificar se LISTA estah cheia
  if (ListaCheia(*Lista) == 1){
    printf("ERRO: lista cheia!\n");return;
  }
  //2 ) criar nova celula a partir da ultima celula
  Lista->Ultimo->Prox = (TipoApontador)
      malloc(sizeof(TipoCelula));
  //3 ) inserir a chave na celula
  Lista->Ultimo->Prox->Item = item;
  //4 ) atualizar apontadores (prim e ult.)
  Lista->Ultimo = Lista->Ultimo->Prox;
  Lista->Ultimo->Prox = NULL;
  //5 ) atualizar tamanho
  Lista->Tamanho++;
}

// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item)
{
  TipoApontador aux, q;
  //1) verificar se LISTA estah vazia
  if(ListaVazia(*Lista) == 1){
    printf("ERRO: lista vazia");return;
  }
  //2) guardar a celula anterior (aux)
  aux = Lista->Primeiro;
  //3) guardar a celula a ser removida (q)
  q = aux->Prox;
  //4) atualizar a celula anterior
  aux->Prox = q->Prox;
  //5) obter o item removido
  *item = q->Item;
  //6) liberar o espaco de memoria de q
  free(q);
  //7) decrementar tamanho
  Lista->Tamanho--;
}

// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item)
{
  TipoApontador aux;
  int i = -1;
  //1) verificar se LISTA estah vazia
  if (ListaVazia(Lista) == 1){
    printf("ERRO: lista vazia!\n");return;
  }
  //2) inicializar o apontador aux
  aux = Lista.Primeiro;
  //3) enquanto houver celula apos aux
  while (aux->Prox != NULL &&
     aux->Prox->Item.Chave != item.Chave){
  //3.1) se a chave que estiver na celula apos aux
  //     for igual a chave procurada
  //3.2) atualizar aux
    aux = aux->Prox;
    i++;
  }
  if (aux->Prox !=NULL){
    // achei
    printf("Elemento encontrado!\n");
  } else {
    // nao achei
    printf("Elemento NAO encontrado!\n");
  }
  return i;
}

// verificar se estah cheia
int ListaCheia(TipoLista Lista){
  if (Lista.Tamanho == Lista.Capacidade)
  {  return 1; // lista cheia
  } else {
    return 0;  //lista nao cheia
  }
}
// verificar se estah vazia
int ListaVazia(TipoLista Lista)
{
  if (Lista.Primeiro == Lista.Ultimo)
  { return 1; // lista vazia
  } else {
    return 0; // lista nao vazia
  }
}
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista){
  return Lista.Tamanho;
}
// imprimir a lista
void ImprimirLista(TipoLista Lista)
{
  TipoApontador aux;
 
  printf("TAD Lista [%d/%d]\n",
     Lista.Tamanho, Lista.Capacidade);
  //1) verificar se LISTA estah vazia
  if (ListaVazia(Lista) == 1){
    printf("ERRO: lista vazia!\n");return;
  }
  //2) inicializar o apontador aux
  aux = Lista.Primeiro;
  //3) enquanto houver celula apos aux
  while (aux->Prox != NULL){
  //3.2) atualizar aux
    printf("%d -> ", aux->Prox->Item.Chave);
    aux = aux->Prox;
  }
  printf("\n\n");
}

2013/2-AED-2013.11.07: TAD Lista - Código fonte em C

// TAD LISTA

// Tipos de dados
typedef int TipoChave;

struct T_Item{
  TipoChave Chave;
};

typedef struct T_Item TipoItem;

typedef struct T_Celula * TipoApontador;

struct T_Celula{
  TipoItem Item;
  TipoApontador Prox;
};

typedef struct T_Celula TipoCelula;

struct T_Lista{
  int Tamanho;
  int Capacidade; 
  TipoApontador Primeiro, Ultimo;
};

typedef struct T_Lista TipoLista;

// Cabeçalho das operações

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item);
// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item);
// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item);
// verificar se estah cheia
int ListaCheia(TipoLista Lista);
// verificar se estah vazia
int ListaVazia(TipoLista Lista);
// criar uma nova lista
void CriarLista(TipoLista * Lista, int capacidade);
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista);
// imprimir a lista
void ImprimirLista(TipoLista Lista);

// Implementação das operações

void CriarLista(TipoLista * Lista, int capacidade){
// 1) criar a celula cabeça
  Lista->Primeiro = (TipoApontador) malloc(
                             sizeof( TipoCelula));
// 2) atualizar os apontadores Prim. e Ult.
  Lista->Ultimo = Lista->Primeiro;
// 3) atualizar o tamanho (zero) e capacidade (parametro)
  Lista->Tamanho = 0;
  Lista->Capacidade = capacidade;
// 4) atualizar o apontador prox da celula cabeca
  Lista->Primeiro->Prox = null;
}

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item)
{
  //1 ) verificar se LISTA estah cheia
  if (ListaCheia(*Lista) == 1){
    printf("ERRO: lista cheia!\n");return;
  }
  //2 ) criar nova celula a partir da ultima celula
  Lista->Ultimo->Prox = (TipoApontador)
      malloc(sizeof(TipoCelula));
  //3 ) inserir a chave na celula
  Lista->Ultimo->Prox->Item = item;
  //4 ) atualizar apontadores (prim e ult.)
  Lista->Ultimo = Lista->Ultimo->Prox;
  Lista->Ultimo->Prox = null;
  //5 ) atualizar tamanho 
  Lista->Tamanho++;
}

// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item)
{
  TipoApontador aux, q;
  //1) verificar se LISTA estah vazia
  if(ListaVazia(*Lista) == 1){
    printf("ERRO: lista vazia");return;
  }
  //2) guardar a celula anterior (aux)
  aux = Lista->Primeiro;
  //3) guardar a celula a ser removida (q)
  q = aux->Prox;
  //4) atualizar a celula anterior
  aux->Prox = q->Prox;
  //5) obter o item removido
  *item = q->Item;
  //6) liberar o espaco de memoria de q
  free(q);
  //7) decrementar tamanho 
  Lista->Tamanho--;
}

// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item)
{
  TipoApontador aux;
  int i = -1;
  //1) verificar se LISTA estah vazia
  if (ListaVazia(Lista) == 1){
    printf("ERRO: lista vazia!\n");return;
  }
  //2) inicializar o apontador aux
  aux = Lista.Primeiro;
  //3) enquanto houver celula apos aux
  while (aux->Prox != null &&
     aux->Prox->Item != item){
  //3.1) se a chave que estiver na celula apos aux
  //     for igual a chave procurada
  //3.2) atualizar aux
    aux = aux->Prox;
    i++;
  }
  if (aux->Prox !=null){
    // achei
    printf("Elemento encontrado!\n");
  } else {
    // nao achei
    printf("Elemento NAO encontrado!\n");
  }
  return i;
}

// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item)
{
 
}
// verificar se estah cheia
int ListaCheia(TipoLista Lista);
// verificar se estah vazia
int ListaVazia(TipoLista Lista);
// criar uma nova lista

// obter o tamanho da lista
int TamanhoLista(TipoLista Lista);
// imprimir a lista
void ImprimirLista(TipoLista Lista);

2013/2-AED-2013.11.01: TAD Lista - Código Fonte em C

// TAD LISTA

// Tipos de dados
typedef int TipoChave;

struct T_Item{
  TipoChave Chave;
};

typedef struct T_Item TipoItem;

typedef struct T_Celula * TipoApontador;

struct T_Celula{
  TipoItem Item;
  TipoApontador Prox;
};

typedef struct T_Celula TipoCelula;

struct T_Lista{
  int Tamanho;
  int Capacidade;  
  TipoApontador Primeiro, Ultimo;
};

typedef struct T_Lista TipoLista;

// Cabeçalho das operações

// inserir uma chave na lista
void InserirLista(TipoLista * Lista, TipoItem item);
// retirar uma chave da lista
void RetirarLista(TipoLista * Lista, TipoItem * item);
// pesquisar por uma chave na lista
int PesquisarLista(TipoLista Lista, TipoItem item);
// verificar se estah cheia
int ListaCheia(TipoLista Lista);
// verificar se estah vazia
int ListaVazia(TipoLista Lista);
// criar uma nova lista
void CriarLista(TipoLista * Lista, int capacidade);
// obter o tamanho da lista
int TamanhoLista(TipoLista Lista);
// imprimir a lista
void ImprimirLista(TipoLista Lista);

// Implementação das operações

void CriarLista(TipoLista * Lista, int capacidade){
// 1) criar a celula cabeça
  Lista->Primeiro = (TipoApontador) malloc(
                             sizeof( TipoCelula));
// 2) atualizar os apontadores Prim. e Ult.
  Lista->Ultimo = Lista->Primeiro;
// 3) atualizar o tamanho (zero) e capacidade (parametro)
  Lista->Tamanho = 0;
  Lista->Capacidade = capacidade;
// 4) atualizar o apontador prox da celula cabeca
  Lista->Primeiro->Prox = null;
}

2013/2:AED-2013.10.17: TAD Fila Laboratório

Applets:
http://www.cosc.canterbury.ac.nz/mukundan/dsal/StackAppl.html
http://www.cosc.canterbury.ac.nz/mukundan/dsal/QueueAppl.html
http://www.cosc.canterbury.ac.nz/mukundan/dsal/appldsal.html

// especificação da TAD fila

// definicao da chave da fila
typedef int TipoChave;
// definicao do registro para o item
struct T_Item{
  TipoChave chave;
};
// definicao do tipo TipoItem
typedef struct T_Item TipoItem;
// definição do apontador para celula
typedef struct T_Celula * TipoApontador;
// definição do registro T_Celula
struct T_Celula{
  TipoItem Item; // item
  TipoApontador Prox; // apontador para prox. celula
};
// definicao do TipoCelula
typedef struct T_Celula TipoCelula;
// definicao do registro T_Fila
struct T_Fila{
  int Tamanho;
  int Capacidade;
  TipoApontador Frente, Tras;
};
// definicao do TipoFila
typedef struct T_Fila TipoFila;

// operacoes da TAD FILA

// enfileirar
void Enfileirar(TipoFila * Fila, TipoItem item);
// desenfileira
void Desenfileirar(TipoFila * Fila, TipoItem * item);
// criar uma fila vazia
void CriarFila(TipoFila * Fila, int capacidade);
// verificar se estah cheia
int FilaCheia(TipoFila Fila);
// verificar se estah vazia
int FilaVazia(TipoFila Fila);
// obter frente
void FilaFrente(TipoFila Fila, TipoItem * item);
// imprimir o conteudo da fila
void ImprimirFila(TipoFila Fila);

// IMPLEMENTACOES DAS OPERACOES
// criar uma fila vazia
void CriarFila(TipoFila * Fila, int capacidade)
{
     // 1) criar a celula cabeca
     Fila->Frente = (TipoApontador) 
       malloc(sizeof(TipoCelula));
     // 2) fazer frente e tras apontar para a nova celula
     Fila->Tras = Fila->Frente;
     // 3) inicializar o tras (prox = NULL)
     Fila->Tras->Prox = NULL;     
     // 4) inicializar o tamanho e a capacidade
     Fila->Tamanho = 0;
     Fila->Capacidade = capacidade;
}

// enfileirar
void Enfileirar(TipoFila * Fila, TipoItem item)
{
     // 1) verificar se a FILA está cheia
     if (FilaCheia(*Fila) == 1){
       printf("ERRO: Fila está cheia!");
       return;
     }
     // 2) criar uma nova celula a partir do TRAS
     Fila->Tras->Prox = (TipoApontador)
       malloc(sizeof(TipoCelula));
     // 3) Adicionar o item na nova celula
     Fila->Tras->Prox->Item = Item;
     // 4) inicializar o PROX da nova celula
     // 5) atualizar o TRAS
     // 6) Atualizar o tamanho da FILA
}

// verificar se estah cheia
int FilaCheia(TipoFila Fila)
{   if (Fila.Capacidade == Fila.Tamanho)
    { return 1;
    } else {
      return 0;
    }
}

// verificar se estah vazia
int FilaVazia(TipoFila Fila)
{   if (Fila.Frente == Fila.Tras)
    { return 1;
    } else {
      return 0;
    }    
}











// especificação da TAD fila

// definicao da chave da fila
typedef int TipoChave;
// definicao do registro para o item
struct T_Item{
  TipoChave chave;
};
// definicao do tipo TipoItem
typedef struct T_Item TipoItem;
// definição do apontador para celula
typedef struct T_Celula * TipoApontador;
// definição do registro T_Celula
struct T_Celula{
  TipoItem Item; // item
  TipoApontador Prox; // apontador para prox. celula
};
// definicao do TipoCelula
typedef struct T_Celula TipoCelula;
// definicao do registro T_Fila
struct T_Fila{
  int Tamanho;
  int Capacidade;
  TipoApontador Frente, Tras;
};
// definicao do TipoFila
typedef struct T_Fila TipoFila;

// operacoes da TAD FILA

// enfileirar
void Enfileirar(TipoFila * Fila, TipoItem item);
// desenfileira
void Desenfileirar(TipoFila * Fila, TipoItem * item);
// criar uma fila vazia
void CriarFila(TipoFila * Fila, int capacidade);
// verificar se estah cheia
int FilaCheia(TipoFila Fila);
// verificar se estah vazia
int FilaVazia(TipoFila Fila);
// obter frente
void FilaFrente(TipoFila Fila, TipoItem * item);
// imprimir o conteudo da fila
void ImprimirFila(TipoFila Fila);

// IMPLEMENTACOES DAS OPERACOES
// criar uma fila vazia
void CriarFila(TipoFila * Fila, int capacidade)
{
     // 1) criar a celula cabeca
     Fila->Frente = (TipoApontador) 
       malloc(sizeof(TipoCelula));
     // 2) fazer frente e tras apontar para a nova celula
     Fila->Tras = Fila->Frente;
     // 3) inicializar o tras (prox = NULL)
     Fila->Tras->Prox = NULL;     
     // 4) inicializar o tamanho e a capacidade
     Fila->Tamanho = 0;
     Fila->Capacidade = capacidade;
}

// enfileirar
void Enfileirar(TipoFila * Fila, TipoItem item)
{
     // 1) verificar se a FILA está cheia
     if (FilaCheia(*Fila) == 1){
       printf("ERRO: Fila está cheia!");
       return;
     }
     // 2) criar uma nova celula a partir do TRAS
     Fila->Tras->Prox = (TipoApontador)
       malloc(sizeof(TipoCelula));
     // 3) Adicionar o item na nova celula
     Fila->Tras->Prox->Item = item;
     // 4) atualizar o TRAS
     Fila->Tras = Fila->Tras->Prox;
     // 5) inicializar o PROX da nova celula
     Fila->Tras->Prox = NULL;
     // 6) Atualizar o tamanho da FILA
     Fila->Tamanho++;
}

// desenfileira
void Desenfileirar(TipoFila * Fila, TipoItem * item)
{    TipoApontador aux; // auxiliar
     // 1) se a FILA estiver vazia
     if (FilaVazia(*Fila) == 1){
       // 1.1) mostrar mensagem de erro e sair
       printf("ERRO: Fila estah vazia!\n");
       return;
     }
     // 2) Guardar a celula que está na frente
     aux = Fila->Frente->Prox;
     // 3) Atualizar a FRENTE (PROX)
     Fila->Frente->Prox = Fila->Frente->Prox->Prox;
     // 4) Decrementar o tamanho
     Fila->Tamanho--;
     // 5) Obter o item removido
     *item = aux->Item;
     // 6) liberar a celula da memoria
     free(aux);
     // 7) Atualizar TRAS se fila estiver vazia
     if (FilaVazia(*Fila) == 1)
     {  Fila->Tras = Fila->Frente;
     }
}
// imprime a fila
void ImprimirFila(TipoFila Fila)
{  printf("Fila %d/%d\n", 
     Fila.Tamanho, Fila.Capacidade);
   // 1) pegando o elemento da frente
   TipoApontador aux = Fila.Frente;
   // 2) Enquanto houver itens para navegar
   while (aux->Prox != NULL)
   { // exibir o item atual
     printf ("%d -> ", aux->Prox->Item.chave);      
     // ir para o próximo elemento
     aux = aux->Prox;
   } printf("\n");   
}
// imprime o elemento na frente da fila
void FilaFrente(TipoFila Fila, TipoItem * item)
{  if (FilaVazia(Fila) == 0){ // se FILA NAO for vazia
     *item = Fila.Frente->Prox->Item;  
   }
}
// verificar se estah cheia
int FilaCheia(TipoFila Fila)
{   if (Fila.Capacidade == Fila.Tamanho)
    { return 1;
    } else {
      return 0;
    }
}

// verificar se estah vazia
int FilaVazia(TipoFila Fila)
{   if (Fila.Frente == Fila.Tras)
    { return 1;
    } else {
      return 0;
    }    
}









#include <stdio.h>
#include <stdlib.h>
#include "tad-fila.h"

int main(int argc, char *argv[])
{
  TipoFila fila;
  TipoItem item;
  
  // 1) Criar fila nova
  CriarFila(&fila, 10);
  ImprimirFila(fila);
  // 2) enfileirar itens
  item.chave = 2;
  Enfileirar(&fila, item);
  item.chave = 3;
  Enfileirar(&fila, item);
  // 3) imprimir fila
  ImprimirFila(fila);
  // 4) desenfileirar itens
  Desenfileirar(&fila, &item);
  printf("Desenfileirou: %d\n", item.chave);
  // 5) imprimir fila
  ImprimirFila(fila);
  
  system("PAUSE");
  return 0;
}