Listas Ligadas

21/04/23 Fábio Lopes Caversan 1

Listas Ligadas

Estruturas de Dados e Algoritmos

Fábio Lopes Caversan 221/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


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


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


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

Banco de memória Variáveis

x y z

nada nada nada


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)


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

z.Push(f) (nada)

y.Pop()

z.Pop() (nada)

x.Pop() (nada)

z.Push(g)


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


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!


Algumas representações do nó ...

Endereço do próximo nó

Informação

nulo


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)


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


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)


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


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;

...

};


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.


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

}

...

};


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




3355 8 nulo8 nulo66pp

3355 8 nulo8 nulo66pp

3355 8 nulo8 nulo66listlist

listlist

listlist


Os passos anteriores são expressos pelo seguinte algoritmo

Node p = new Node();

p.Info = x;

p.Next = list;

list = p;


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


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

Node p = list;

list = p.Next;

x = p.Info;


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


Uma pilha usando lista ligada

7 nulo7 nulo55 33 88

7 nulo7 nulo55 33 8866

stackstack

stackstack


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;


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;

}


Uma fila usando lista ligada

3 nulo3 nulo11 77 9944

6 nulo6 nulo77 99 3344 11

inícioinício

inícioinício finalfinal

finalfinal


Algoritmo para x = q.Remove ()

if (Empty())

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

Node p = front;

x = p.Info;

front = p.Next;

if (front = = null)

rear = null;

p = null;

return ( x );

A fila q consiste numa fila e dois A fila q consiste numa fila e dois ponteiros: front e rear. As operações ponteiros: front e 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 front por stack.front por stack.

Muita atenção ao remover o último Muita atenção ao remover o último elemento da fila: rear fica também nulo elemento da fila: rear fica também nulo porque se a fila está vazia front e rear porque se a fila está vazia front e rear devem ser nulosdevem ser nulos


Algoritmo para q.Insert (x)

Node p = new Node();

p.Info = x;

p.Next = null;

if (rear = = null )

front = p;

else

rear.Next = p;

rear = p;


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


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


x0x1x2x3x4x5

x0x1x2x

x3x4x5x6

x0x1x2

x3x4x5

Inserção de um novo elemento num vetor


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;

Listas Ligadas

Documents

Transcript of Listas Ligadas