1/3/2014Fábio Lopes Caversan 1 Listas Ligadas Estruturas de Dados e Algoritmos

11/04/23 Fábio Lopes Caversan 1

Listas Ligadas

Estruturas de Dados e Algoritmos

Fábio Lopes Caversan 211/04/23

Listas Ligadas

Desvantagens do armazenamento seqüencial para representar pilhas e filas:Subdimensionamento ou

superdimensionamento da memória devido a alocação fixa de uma certa quantidade de memória antes da execução do programa

Possibilidade de overflow

Fábio Lopes Caversan 311/04/23

Compartilhando a memória disponível

Suponha uma implementação seqüencial de pilhas

Stack x,y,z; Suponha que sejam inicializadas, de forma

estática, com 50 elementos x,y,z terão, durante a utilização,

respectivamente, no máximo, 20, 10 e 70 elementos

Fábio Lopes Caversan 411/04/23

Fazendo cálculos 100 células seriam necessárias Porém, na inicialização, deve-se usar o

tamanho 70 para não ocorrer um overflow Então, temos 3* 70 = 210,quando

somente 100 serão utilizadas Que tal evitar esse desperdício através de

um gerenciador de memória? Ele controlaria quem recebe mais ou

menos células de memória

Fábio Lopes Caversan 511/04/23

Agrupando as células livres num banco de memória livre

Banco de memória Variáveis

x y z

nada nada nada

Fábio Lopes Caversan 611/04/23

Operação Banco de memória x y z

x.Push(a) (nada) (nada)

y.Push(b) (nada)

y.Push(c) (nada)

x.Push(d) (nada)

z.Push(e) (nada)

Fábio Lopes Caversan 711/04/23

Operação Banco de memória x y z

z.Push(f) (nada)

y.Pop()

z.Pop() (nada)

x.Pop() (nada)

z.Push(g)

Fábio Lopes Caversan 811/04/23

Considerações importantes

A ordem das células de memória disponíveis no banco, no decorrer da execução da aplicação, muda substancialmente

O importante é manter um controle sobre a ordem lógica das células de memória e não, necessariamente, sobre a ordem física

Fábio Lopes Caversan 911/04/23

Lista Ligada (Encadeada) Linear

Cada item na lista é um nó Todo nó contem dois campos: o de

informação e do endereço seguinte Campo de informação: armazena o real

elemento da lista Campo de endereço: endereço do

próximo nó na lista. É um ponteiro!

Fábio Lopes Caversan 1011/04/23

Algumas representações do nó ...

Endereço do próximo nó

Informação

nulo

Fábio Lopes Caversan 1111/04/23

Continuando . . . A lista ligada inteira é acessada a partir de um ponteiro

externo que aponta para o primeiro nó da lista Um ponteiro externo não está incluindo dentro de um nó. É

acessado por referência a uma variável O campo do próximo endereço do último nó da lista contém

um valor especial: null O ponteiro nulo (null) marca o final da lista Uma lista sem nós é uma lista vazia ou nula Nesse caso, o ponteiro externo para a lista é nulo Uma lista pode ser inicializada por uma operação do tipo list

= null (sendo list o ponteiro externo)

Fábio Lopes Caversan 1211/04/23

Uma lista ligada

Info next info next info next infonext

Lista nulo

nó nó nó nó

Fábio Lopes Caversan 1311/04/23

Revisando o mapa conceitual de um programa na memória

Pilha

Heap

Variáveis Globais

Código do Programa

Endereços de retorno de funções, variáveis locais

Alocação dinâmica: listas encadeadas

Fábio Lopes Caversan 1411/04/23

Ao “fotografar” a memória do computador

LISTLIST

Ponteiro externo que aponta para o primeiro nó da lista ligada. Cuidado com sua manipulação!

Programa Área Livre (Heap)

Fábio Lopes Caversan 1511/04/23

N1N1 NNnn nullnullN2N2 N3N3 . . .LL

Dois endereços merecem atenção especial:

• O endereço L do nó inicial que permite identificar em que parte da memória inicia-se a lista

• O endereço NULL que vem após o nó final. É onde termina a lista

Sempre lembrando, cada nó i é composto de duas partes:

• Info: área onde é armazenado o i-ésimo elemento da lista

• Next: área onde é armazenado o “endereço” do nó N i + 1

Fábio Lopes Caversan 1611/04/23

Declarando uma classe Nó para uma lista ligada

Um dos atributos da classe precisa ser um ponteiro para uma estrutura do mesmo tipo

public class Node {

private object info;

private Node next;

...

};

Fábio Lopes Caversan 1711/04/23

Permitindo o acesso aos atributos De acordo com a linguagem, pode ser

necessária a escrita de métodos para ler e escrever nos atributos, garantindo o encapsulamento.

Nas linguagens que possuem propriedades, isso pode ser feito com os comandos get e set.

Cada vez que atribuímos um valor para a propriedade, o set é chamado. Cada vez que lemos um valor da propriedade, o get é chamado.

Fábio Lopes Caversan 1811/04/23

public class Node {

private object info;

private Node next;

public object Info {

get {return info;}

set {info = value;}

}

public Node Next {

get {return next;}

set {next = value;}

}

...

};

Fábio Lopes Caversan 1911/04/23

listlist

Incluindo um elemento no início da lista

55

3355

66

55 33 8 nulo8 nulo

33 8 nulo8 nulo

8 nulo8 nulo

info next info next info nextinfo next info next info next

pp

listlist

listlist

pp

info next info next info nextinfo next info next info next

info next info next info nextinfo next info next info next

Fábio Lopes Caversan 2011/04/23

3355 8 nulo8 nulo66pp

3355 8 nulo8 nulo66pp

3355 8 nulo8 nulo66listlist

listlist

listlist

Fábio Lopes Caversan 2111/04/23

Os passos anteriores são expressos pelo seguinte algoritmo

Node p = new Node();

p.Info = x;

p.Next = list;

list = p;

Fábio Lopes Caversan 2211/04/23

Removendo um nó do início de uma lista

listlist

77

55

55

9 nulo9 nulo

9 nulo9 nulo

55 9 nulo9 nulo

77

55 9 nulo9 nulo77

77info nextinfo next info next info next info next info next

77 9 nulo9 nulo55

9 nulo9 nulo55

listlist

PPlistlist

listlist

listlist

X=7 PX=7 P

PP

PP

listlist

Fábio Lopes Caversan 2311/04/23

Os passos anteriores para remover um nó são expressos pelo seguinte algoritmo

Node p = list;

list = p.Next;

x = p.Info;

Fábio Lopes Caversan 2411/04/23

Implementação ligada de Pilhas Incluir um elemento no início de uma lista

ligada é semelhante à inclusão numa pilha O 1º nó da lista representa o topo da pilha Vantagem: todas as pilhas ou filas usadas por

um programa podem compartilhar a mesma lista de nós disponíveis, desde que não ultrapassam a quantidade total de nós disponíveis

Fábio Lopes Caversan 2511/04/23

Uma pilha usando lista ligada

7 nulo7 nulo55 33 88

7 nulo7 nulo55 33 8866

stackstack

stackstack

Fábio Lopes Caversan 2611/04/23

Como o 1º nó da lista é o topo da lista

A implementação de Push (x) poderia ficar:

Node p = new Node( );

p.Info = x;

p.Next = stack;

stack = p;

Fábio Lopes Caversan 2711/04/23

A implementação de x = pop (s) poderia ficar :if (Empty ())

// Exception, mensagem, etc...

else {

Node p = stack;

stack = p.Next;

x = p.Info;

p = null;

return x;

}

Fábio Lopes Caversan 2811/04/23

Uma fila usando lista ligada

3 nulo3 nulo11 77 9944

6 nulo6 nulo77 99 3344 11

inícioinício

inícioinício finalfinal

finalfinal

Fábio Lopes Caversan 2911/04/23

Algoritmo para x = q.Remove ()

if (Empty())

// Exceção, mensagem, etc...

Node p = q.Front;

x = p.Info;

q.Front = p.Next;

if (q.Front = = null)

q.Rear = null;

P = null;

return ( x );

A fila q consiste numa fila e dois A fila q consiste numa fila e dois ponteiros: q.Front e q.Rear. As operações ponteiros: q.Front e q.Rear. As operações q.Empty() e x=q.Remove() são análogas a q.Empty() e x=q.Remove() são análogas a s.Empty(s) e x=s.Pop(s), basta substituir s.Empty(s) e x=s.Pop(s), basta substituir q.Front por s.q.Front por s.

Muita atenção ao remover o último Muita atenção ao remover o último elemento da fila: q.Rear fica também nulo elemento da fila: q.Rear fica também nulo porque se a fila está vazia q.Front e porque se a fila está vazia q.Front e q.Rear devem ser nulosq.Rear devem ser nulos

Fábio Lopes Caversan 3011/04/23

Algoritmo para q.Insert (x)

Node p = new Node();

p.Info = x;

p.Next = null;

if (q.Rear = = null )

q.Front = p;

else

q.Rear.Next = p;

q.Rear = p;

Fábio Lopes Caversan 3111/04/23

Desvantagens de pilhas e filas como listas ligadas?

Mais armazenamento do que o vetor: Info e Next Mas o espaço de armazenamento não é o dobro.

Depois, pode-se compactar as informações Cada inclusão/exclusão corresponde a uma

inclusão/exclusão na lista de nós disponíveis Grande vantagem: compartilhamento de nós,

desde que não ultrapasse o número de nós disponíveis

Fábio Lopes Caversan 3211/04/23

Listas ligadas como estruturas de dados

São importantes não só para implementar pilhas e filas, mas como estruturas de dados

Acessa-se um item percorrendo-se a lista a partir do início

Um vetor permite o acesso direto ao enésimo item com uma única operação

Já uma lista exige n operações e é necessário percorrer cada um dos primeiros n-1 elementos antes do enésimo

Vantagem da lista: aparece na inserção ou remoção de um elemento porque não é necessário nenhuma movimentação dos n elementos

Fábio Lopes Caversan 3311/04/23

x0x1x2x3x4x5

x0x1x2x

x3x4x5x6

x0x1x2

x3x4x5

Inserção de um novo elemento num vetor

Fábio Lopes Caversan 3411/04/23

InsertAfter (n,x)

Node p = new Node()

p.Info = x;

p.Next = n.Next;

n.Next = p

X

X4 nuloX0 X1 X2 X3listlist

nn

X4 nuloX0 X1 X2 X3listlist

nn

Já numa lista o trabalho de inserção independe do seu tamanho

DeleteAfter(n)

Node p = n.Next;

x = p.Info;

n.Next = p.Next;

p = null;