AULA 20 - Programação 1 - Graduação

Objetivos

• Apresentar as listas encadeadas;
• Apresentar algumas aplicações.

Listas Encadeada

Trata-se uma representação de uma sequência de objetos, todos do mesmo tipo, na memória do computador. Cada elemento da sequência é armazenado em uma célula da lista: o primeiro elemento na primeira célula, o segundo na segunda e assim por diante.

Por vezes não se conhece o tamanho dos dados que se vai manipular e o uso de uma lista pode ser conveniente para armazená-los. Um sistema de estoque de produtos, por exemplo, poderia ser armazenado na forma de uma lista. O exercício a seguir explora esta estrutura.

Exercício de lista ligada

#include <stdlib.h>
#include <stdio.h>

/*========================*/
/** OPERAÇÔES COM LISTA LIGADA ******/
/*========================*/

/*
   tipos e variáveis globais
*/

struct TProduto{
   int codigo;
  struct TProduto *next;
} *head, *tail;


/*
   adiciona item a cabeça da lista
   retorna 0 se tudo ok e -1 se erro
*/
int add_nodo_head(int codigo)
{

}

/*
   adiciona item ao final  lista
   retorna 0 se tudo ok e -1 se erro
*/
int add_nodo_tail(int codigo)
{
   struct TProduto *p =  malloc (sizeof(struct TProduto));
   if (!p)
        return -1;

   p->codigo = codigo;
   p->next = NULL;

   if (tail==NULL) {
      /* lista vazia */
      tail = head = p;
   }else {
     /*lista não vazia */
       tail->next = p;
       tail = p;
   }
   return 0;
}

/*
   imprimir lista 
*/

void print_list()
{

}
 
main()
{
  int i;

  head = tail = NULL;
  print_list ();
  for (i=0;i<5;i++)
     add_nodo_tail(i);

  print_list ();
}

Exercício 1

No exercício anterior:

• Implementar a função add_node_head()
• Implementar a função print_list()
• Implementar a função delete_node(int codigo)

Exercício 2

Considere um sistema de estoque de uma livraria representado por uma tabela conforme abaixo. Elabore as funções para adicionar, remover e listar um livro na/da tabela. Considere que uma entrada livre possui o ponteiro titulo igual a NULL.

#include <stdio.h>
#define TAM 10
 
 
struct tLivro {
  char *titulo;
  char *autor;
  char *isbn;
  float *preco;
  int  estoque;
};
 
 
typedef struct tLivro TLivro;
 
TLivro Livros[10]; /* iniciar a tabela com NULL */
 
 
 
TLivro *retornar_entrada_livre()
{
}
 
int adicionar_livro()
{
 char aux_isbn[20];
 TLivro *p;

 /* Ler ISBN */
 if(verificar_livro_existe(aux_isbn)==1)
    return 0;
 if((p=retornar_entrada_livre())==NULL)
    return -1;
 
 /* Ler os dados do livro pelo teclado e colocar na estrutura 
    apontada por p*/
 
}
 
/* retorna 0 se removido com sucesso e -1 caso contrário */
int remover_livro(char *isbn)
{
}
 
void imprimir_dados_livro(char *isbn)
{
}
 
main()
{
 /* testar as funções aqui */
}

Exercício 3

Refazer o exercício anterior usando filas.

Exercício 5

Seja a seguinte estrutura:

struct tipo_carro {
   char *marca;
   char *modelo;
   int  potencia;
};

typedef tipo_carro tcarro;

Implpementar as funções abaixo:

/* cria dinamicamente uma estrutura,
   preenche os dados dos campos
   e retorna um ponteiro para a estrutura criada
   Retorna NULL caso não consiga alocar área
 */
tcarro *ler_carro()
{
}

/*
  recebe dois ponteiros para estruturas do tipo carro e
  retorna -1 caso pelo menos um dos ponteiros seja NULL,
  retorna 0 se os modelos forem iguais
  e retorna 1 se os modelos forem diferentes */
int compara_modeloa(tcarro *p1, tcarro *p2)
{
}

/* libera a área da estrutura passada como parâmetro */
void deleta_estrutura(tcarro *p)
{
}

main()
{
  /*testar as funções aqui */
  /* criar dois carros */
  /* comparar o modelo dos dois carros. Testar o retorno */
  /* liberar a área das estruturas */
}