listascbarrico/disciplinas/programacaoalgorit... · 2018-10-15 · listas a estrutura de dados...

1/36

LISTAS

Listas Programação II

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.



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).



Exemplos mais comuns

- Listas,

- Pilhas,

- Filas, e

- Árvores.


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;



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



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.


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.



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.



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.



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 (L0) com sucessor (L1) e sem antecessor;

- o elemento de índice N-1 (LN-1) com antecessor (LN-2) e sem sucessor;

- o elemento da lista com índice k (Lk) tem:

- o elemento de índice k-1 como seu antecessor (Lk-1),

- o elemento de índice k+1 como seu sucessor (Lk+1).


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;

0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 . . .



Exemplo

#define TamMax 100


0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 . . .

N = 100;

0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 . . .



Exemplo

#define TamMax 100


0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 . . .

N = 100;

0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 . . .

N = 102;

ERRO (overflow): N > TamMax (102 > 100)



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


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));

0 1 . . . 48 49

9 14 . . . 27 35



Exemplo

int *Lista, N = 50; Lista = (int *) malloc(N * sizeof(int));

0 1 . . . 48 49

9 14 . . . 27 35

N = 100;

Lista = (int *) realloc(Lista, N * sizeof(int));

0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 51 . . . 176 185



Exemplo

int *Lista, N = 50; Lista = (int *) malloc(N * sizeof(int));

0 1 . . . 48 49

9 14 . . . 27 35

N = 100;


0 1 . . . 48 49 50 . . . 98 99

9 14 . . . 27 35 51 . . . 176 185

N = 102;


0 1 . . . 48 49 50 . . . 98 99 100 101

9 14 . . . 27 35 51 . . . 176 185 245 267



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



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.



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).



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



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;}



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



Criar uma lista


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;

}



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.



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



Inserir no início


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

}



Inserir no fim

- Neste caso, apenas é necessário introduzir o novo elemento na última posição

da lista (nova posição).




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



Inserir no fim


ELEMENTO *InserirFim (ELEMENTO X, ELEMENTO L[], int *N) {


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)


return L; // operação com êxito – novo elemento inserido

}



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.



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



Inserir por ordem


ELEMENTO *InserirOrdem (ELEMENTO X, ELEMENTO L[], int *N) {

int k, pos = 0;


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


return L; // novo elemento inserido

}



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).


Dados de entrada: o elemento X, uma lista L e o tamanho da lista (N)


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



Remover um elemento de uma lista


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;

}



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)


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



Remover um elemento de uma lista (outra forma)


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;

}


listascbarrico/disciplinas/programacaoalgorit... · 2018-10-15 · listas a estrutura de dados...

Documents