1/36 LISTAS. Programação II

Transcrição

1 1/36 LISTAS

2 Estrutura de Dados 2/36 Estrutura de Dados Definição - Uma Estrutura de Dados é: - uma coleção de tipos de dados, composta por tipos não estruturados básicos, tipos estruturados ou uma mistura de ambos, - um conjunto de operações definidas sobre os tipos de dados. - Por outras palavras, uma estrutura de dados é composta por 3 partes: - um conjunto de operações; - uma estrutura de armazenamento especificando as classes de dados relacionados e as coleções de variáveis; - um conjunto de algoritmos, uma para cada operação. Cada algoritmo procura e modifica a estrutura de armazenamento para alcançar o resultado definido pela operação.

3 Estrutura de Dados 3/36 Exemplo - um conjunto de variáveis inteiras e - o conjunto de operações aritméticas simples (adição, subtração, multiplicação, divisão, negação, valor absoluto, etc.) sobre elas. Classificação - Existem 2 classes de estrutura de dados, as quais estão relacionadas com o tipo do armazenamento requerido: - Estática (fixa): estrutura cujo tamanho e atribuição de memória associadas são fixadas aquando da compilação do programa; - Dinâmica: estrutura cujo tamanho aumenta ou diminui consoante as necessidades durante a execução do programa (em que a localização da memória a si associada poderá ser alterada).

4 Estrutura de Dados 4/36 Exemplos mais comuns -, - Pilhas, - Filas, e - Árvores.

5 A estrutura de Dados Lista 5/36 A estrutura de Dados Lista Definição É uma sequência linear de tipos de dados do mesmo tipo Tem as seguintes propriedades - Existe um primeiro elemento (a cabeça) com um único sucessor (o próximo); - Existe um último elemento (a cauda) sem sucessor; - Qualquer outro elemento tem um sucessor e um antecessor;

6 A estrutura de Dados Lista 6/36 Sobre uma lista realizam-se as seguintes operações - Criar um elemento - Criar uma lista - Verificar se uma lista está vazia (não tem elementos) - Pesquisar um elemento numa lista - Remover/eliminar um elemento de uma lista - Inserir um elemento numa lista (no início, no fim e numa lista ordenada) - Atualizar um elemento de uma lista - Ordenar uma lista - Imprimir/listar uma lista - Determinar a quantidade de elementos de uma lista (tamanho/comprimento) - Eliminar/destruir uma lista

7 A estrutura de Dados Lista 7/36 Os elementos numa lista - estão sempre ligados pela sua relação sucessor-antecessor. Uma ED Lista pode ser implementada - num espaço de armazenamento sequencial ou - num espaço de armazenamento não sequencial. Implementação num espaço de armazenamento sequencial - podem-se usar vetores, os quais podem ser declarados usando - memória estática ou - memória dinâmica. Implementação num espaço de armazenamento não sequencial - podem-se usar ponteiros e memória dinâmica.

8 Armazenamento Sequencial 8/36 Armazenamento Sequencial Todos os dados na estrutura são mantidos num vetor Os vetores podem ser definidos de duas formas - usando memória estática, em que o tamanho é fixado quando o programa é escrito, não podendo ser alterado enquanto o programa está a ser executado, ou - usando memória dinâmica, em que o tamanho é alterado à medida que o programa vai sendo executado, consoante as necessidades de espaço de armazenamento.

9 Armazenamento Sequencial 9/36 No caso de se usar memória estática - Quando se está a escrever um programa, - tem que se decidir qual o tamanho máximo (de memória) que será necessário para os vetores, e - estabelecer este limite nas declarações. - Problemas: - Se o programa for executado com um pequeno conjunto de dados, então muito deste espaço nunca vai ser utilizado (desperdício de memória). - Se o programa for executado com um grande conjunto de dados, então pode-se esgotar o espaço estabelecido na declaração e encontrar uma situação de overflow. Isto pode ocorrer mesmo no caso da memória do computador não estar totalmente usada, devido ao tamanho máximo do vetor ser muito baixo.

10 Armazenamento Sequencial 10/36 No caso de se usar memória dinâmica - Apenas é necessário declarar um apontador/ponteiro para uma variável do mesmo tipo dos elementos da lista. - A lista vai crescendo em tamanho à medida das necessidades de inserção de elementos na lista. - Problema: - possibilidade de inexistência de um bloco de memória contígua necessário para receber todos os elementos da lista. - Este problema pode ser ultrapassado usando outra forma de manter as estruturas de dados na memória (sem vetores), como é o caso de listas ligadas.

11 Armazenamento Sequencial 11/36 A definição de um elemento da Lista é composta pelos campos - Dados; - Chave (opcional) - campo pelo qual a lista está ordenada; - Localização (índice) na lista. Numa lista L - o elemento de índice 0 (L 0 ) com sucessor (L 1 ) e sem antecessor; - o elemento de índice N-1 (L N-1 ) com antecessor (L N-2 ) e sem sucessor; - o elemento da lista com índice k (L k ) tem: - o elemento de índice k-1 como seu antecessor (L k-1 ), - o elemento de índice k+1 como seu sucessor (L k+1 ).

12 Armazenamento sequencial com memória estática 12/36 Armazenamento sequencial com memória estática Exemplo #define TamMax 100 int Lista[TamMax], N = 50;

13 Armazenamento sequencial com memória estática 13/36 Exemplo #define TamMax 100 int Lista[TamMax], N = 50; N = 100;

14 Armazenamento sequencial com memória estática 14/36 Exemplo #define TamMax 100 int Lista[TamMax], N = 50; N = 100; N = 102; ERRO (overflow): N > TamMax (102 > 100)

15 Armazenamento sequencial com memória estática 15/36 Tamanho máximo - Constante (= TamMax) Þ Ineficiência Acesso - Direto Tamanho efetivo - Necessário atualizar e testar eventual transbordo (> TamMax) Reordenamento - Trocas (ou vetor auxiliar) Inserção/Remoção de elementos - Deslocamento de todos os elementos seguintes

16 Armazenamento sequencial com memória dinâmica 16/36 Armazenamento sequencial com memória dinâmica Exemplo int *Lista, N = 50; Lista = (int *) malloc(n * sizeof(int));

17 Armazenamento sequencial com memória dinâmica 17/36 Exemplo int *Lista, N = 50; Lista = (int *) malloc(n * sizeof(int)); N = 100; Lista = (int *) realloc(lista, N * sizeof(int));

18 Armazenamento sequencial com memória dinâmica 18/36 Exemplo int *Lista, N = 50; Lista = (int *) malloc(n * sizeof(int)); N = 100; Lista = (int *) realloc(lista, N * sizeof(int)); N = 102; Lista = (int *) realloc(lista, N * sizeof(int));

19 Armazenamento sequencial com memória dinâmica 19/36 Tamanho máximo - Variável Þ Eficiência Tamanho efetivo - Necessário atualizar para alocar memória dinâmica; - Testar disponibilidade de memória antes de aumentar o tamanho. Acesso - Direto Reordenamento - Trocas (ou vetor auxiliar) Inserção/Remoção de elementos - Deslocamento de todos os elementos seguintes

20 Armazenamento sequencial com memória dinâmica 20/36 Declaração - Os elementos de uma lista podem ser definidos como - um tipo qualquer simples (por exemplo: inteiro, real ou carácter) ou - estruturado (por exemplo: registo). - Uma lista pode ser definida como um vetor ( array ). - Portanto, antes de se definir uma lista tem que se definir os elementos da lista.

21 Armazenamento sequencial com memória dinâmica 21/36 Declaração (exemplo) typedef struct { char Nome[50]; int Idade, BI; char Sexo[1]; // Masculino(M/m) ou Feminino(F/f) } ELEMENTO; ELEMENTO *Lista; int N; Cada um dos elementos consiste no seguinte - Dados, é a informação associada a cada elemento (Nome, Idade, BI e Sexo) - Chave, é o campo que servirá de base para ordenar a lista (por ex: Nome) - N, é o número de elementos (tamanho) da Lista - Localização, é o índice que lhe está associado (entre 0 e N-1).

22 Armazenamento sequencial com memória dinâmica 22/36 Criar um elemento - Quando se pretende inserir um novo elemento numa lista, este deve ser criado antes; isto é, atribuir valores a todos os campos da estrutura que suporta a informação associada a cada elemento da lista. - Um possível algoritmo para criar um elemento é o seguinte: Dados de entrada: -- Dados de saída: retorna o endereço de um elemento E (criado e preenchido com a informação desejada localmente, usando alocação de memória) Algoritmo: Para cada campo do elemento E fazer Pedir informação Introduzir informação

23 Armazenamento sequencial com memória dinâmica 23/36 Criar um elemento - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *CriarElemento () { ELEMENTO *E; E = (ELEMENTO *) malloc(sizeof(elemento)); } if (E == NULL) return NULL; printf( Insira o nome : \n ); gets(e->nome); printf( Insira a idade : \n ); scanf( %d, &(E->Idade)); printf( Insira o BI : \n ); scanf( %d, &(E->BI)); printf( Insira o sexo (M/m; F/f) : \n ); gets(e->sexo); return E;

24 Armazenamento sequencial com memória dinâmica 24/36 Criar uma lista - Quando se pretende criar uma lista, isto deve ser realizado com a introdução de um elemento (que será o primeiro). - Um possível algoritmo para criar uma lista é o seguinte: Dados de entrada: -- Dados de saída: a lista L com um só elemento e o seu tamanho (que é 1) Algoritmo: Criar um novo elemento Inserir o novo elemento na posição 1 (índice 0) da lista L (L[0]) Atualizar o tamanho da lista, atribuindo o valor 1 a N

25 Armazenamento sequencial com memória dinâmica 25/36 Criar uma lista - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *CriarLista (int *N) { ELEMENTO *L, *E; E = CriarElemento(); L = (ELEMENTO *) malloc(sizeof(elemento)); if (L == NULL) return NULL; L[0] = *E; *N = 1; free(e); return L; }

26 Armazenamento sequencial com memória dinâmica 26/36 Inserir um elemento numa lista - Na resolução deste problema tem de ser analisadas três situações distintas, consoante a forma como se pretende inserir o elemento: - no início, - no fim ou - com a lista ordenada.

27 Armazenamento sequencial com memória dinâmica 27/36 Inserir no início - Começa-se por avançar uma posição a todos os elementos da lista, para que a 1ª posição fique livre para receber o novo elemento. - Um possível algoritmo é o seguinte: Dados de entrada: o elemento X, a lista L e o tamanho da lista (N) Dados de saída: a lista L e o seu tamanho (N) atualizados Algoritmo: Realocar memória para mais um elemento Avançar uma posição todos os elementos da lista L Inserir X na posição 1 (índice 0) Atualizar o tamanho da lista, incrementando um valor a N

28 Armazenamento sequencial com memória dinâmica 28/36 Inserir no início - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *InserirInicio (ELEMENTO X, ELEMENTO L[], int *N) { int k; L = (ELEMENTO *) realloc(l, (*N+1) * sizeof(elemento)); if (L == NULL) } return NULL; // impossível alocar memória para um novo elemento for (k = *N; k > 0; k--) L[k] = L[k-1]; // avançar todos os elementos da lista uma posição L[0] = X; // colocar o elemento X na 1ª posição (índice 0) *N = *N + 1; // atualizar o tamanho da lista, incrementando um valor return L; // operação com êxito novo elemento inserido

29 Armazenamento sequencial com memória dinâmica 29/36 Inserir no fim - Neste caso, apenas é necessário introduzir o novo elemento na última posição da lista (nova posição). - Um possível algoritmo é o seguinte: Dados de entrada: o elemento X, a lista L e o tamanho da lista (N) Dados de saída: a lista L e o seu tamanho (N) atualizados Algoritmo: Realocar memória para mais um elemento Inserir X na posição N+1 (uma posição à frente do último elemento da lista) Atualizar o tamanho da lista, incrementando-o num valor

30 Armazenamento sequencial com memória dinâmica 30/36 Inserir no fim - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *InserirFim (ELEMENTO X, ELEMENTO L[], int *N) { L = (ELEMENTO *) realloc(l, (*N+1) * sizeof(elemento)); if (L == NULL) } return NULL; // impossível alocar memória para um elemento L[*N] = X; // colocar o elemento X na última posição (*N-1) *N = *N + 1; // atualizar o tamanho da lista, incrementando um valor return L; // operação com êxito novo elemento inserido

31 Armazenamento sequencial com memória dinâmica 31/36 Inserir por ordem - É o caso mais utilizado. Começa por pesquisar a posição pos onde inserir o novo elemento; depois, todos os elementos que se posicionem depois de pos avançam uma posição, ficando a posição pos livre para receber o novo valor. - Um possível algoritmo é o seguinte: Dados de entrada: o elemento X, a lista L e o tamanho da lista (N) Dados de saída: a lista L e o seu tamanho atualizados Algoritmo: (lista ordenada crescentemente pelo campo BI) Determinar a posição k onde inserir o elemento X Avançar uma posição todos os elementos da lista L que estão depois da posição k Inserir X na posição k Atualizar o tamanho da lista, incrementando-o num valor

32 Armazenamento sequencial com memória dinâmica 32/36 Inserir por ordem - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *InserirOrdem (ELEMENTO X, ELEMENTO L[], int *N) { int k, pos = 0; L = (ELEMENTO *) realloc(l, (*N+1) * sizeof(elemento)); if (L == NULL) } return NULL; // não há memória para inserir o novo elemento while ((pos < *N) && (L[pos].BI < X.BI)) // lista ordenada pelo campo BI pos = pos + 1; // o elemento X deve ser inserido na posição pos for (k = *N; k > pos; k--) L[k] = L[k-1]; // avançar uma posição os elementos da lista após pos L[pos] = X; // colocar o elemento X na posição pos *N = *N + 1; // atualizar o tamanho da lista, incrementando um valor return L; // novo elemento inserido

33 Armazenamento sequencial com memória dinâmica 33/36 Remover um elemento de uma lista - Consiste em eliminar um dado elemento de uma lista ordenada ou não. - A diferença, em termos algorítmicos, entre estas duas situações encontra-se na forma de pesquisar a posição do elemento a remover. Basta aplicar um dos métodos existentes que mais se adequar à lista (ordenada ou não ordenada). - Um possível algoritmo é o seguinte: Dados de entrada: o elemento X, uma lista L e o tamanho da lista (N) Dados de saída: a lista L e o seu tamanho (N) atualizados Algoritmo: k posição do elemento X na lista L (utilizar um dos métodos de pesquisa) Recuar uma posição todos os elementos que estão depois do elemento da posição k Atualizar o tamanho da lista, decrementando N em um valor Atualizar lista, removendo o último elemento realocando memória

34 Armazenamento sequencial com memória dinâmica 34/36 Remover um elemento de uma lista - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *Remover (ELEMENTO X, ELEMENTO L[], int *N) { int k, pos, *aux; } pos = PesquisaExaustiva(X, L, *N); // lista ordenada ou não if (pos >= 0) { // o elemento a remover, X, pertence à lista for (k = pos; k < *N-1; k++) L[k] = L[k+1]; *N = *N 1; // atualizar o tamanho da lista, decrementando um valor L = (ELEMENTO *) realloc(l, (*N) * sizeof(elemento)); //atualizar L } return L;

35 Armazenamento sequencial com memória dinâmica 35/36 Remover um elemento de uma lista (outra forma) - Consiste em fornecer a posição do elemento a remover - O processo consiste, então, no seguinte: - verificar se o elemento a remover se encontra na lista - pesquisar a posição do elemento a remover, usando um dos métodos para o efeito; - remover o elemento da lista, caso exista. Um possível algoritmo é o que se segue. Dados de entrada: a posição (pos) do elemento, a lista L e o seu tamanho (N) Dados de saída: a lista L e o seu tamanho (N) atualizados Algoritmo: Recuar uma posição todos os elementos que se encontram em posição após pos Atualizar o tamanho da lista, decrementando N em um valor Atualizar lista, removendo o último elemento realocando memória

36 Armazenamento sequencial com memória dinâmica 36/36 Remover um elemento de uma lista (outra forma) - Uma possível função que traduz o algoritmo é a seguinte: ELEMENTO *Remover (int pos, ELEMENTO L[], int *N) { int k; for (k = pos; k < *N-1; k++) } L[k] = L[k+1]; // recuar uma posição os elementos desde k *N = *N 1; // atualizar o tamanho da lista (decrementar um valor a N) L = (ELEMENTO *) realloc(l, (*N) * sizeof(elemento)); // atualizar lista return L;