Você está na página 1de 13

Listas, Filas e Pilhas

Katia Guimares

Operaes com listas


O incio da lista identificado por um ponteiro
especial (varivel tipo endereo) chamado Head.
Head

...

Null

O final da lista pode ser implementado com:


1. NULL/NIL - Endereo especial .
2. Sentinela Registro contendo uma chave especial.
(Requer o uso de apontador para o ltimo elemento)

Tipos de Lista
1. Lista duplamente encadeada
Cada elemento um objeto com um campo chave
e dois ponteiros: ant e prox .
ant

(Dados)

prox

2. Lista simplesmente encadeada


Omitimos em cada elemento o ponteiro ant .
3. Lista circular
O ponteiro ant do primeiro elto. da lista aponta para o
ltimo elto., e o ponteiro prox do ltimo elto. aponta
para o primeiro elemento.

Operaes em Lista - Busca


Lista-Busca(L,k) Encontra o primeiro elemento com
chave k na lista L por uma busca linear simples,
retornando um ponteiro para este elemento.
Lista-Busca (L,k)
Entrada: Lista de elementos L, elto k para a busca.
Sada: Ponteiro para o registro que contm o elemento k.
Incio
1. x := header(L)
2. enquanto x nil e chave(x) k
3. faa x := prox(x)
4. devolva x
Fim
Custo: T(n) = (n) (No pior caso pode percorrer toda a lista).

Operaes em Lista - Insero


Lista-Insero (L,x) Dado um elemento x, o procedimento
inclui um registro no incio da lista com o elemento x.
Lista-Insero(L,x)
Entrada: lista de elementos L.
Sada: lista de elementos (L + x).
Incio
1. prox(x) := head(L)
2. se head(L) # nil
3. ento ant(head(L)) := x
4. head(L) := x
5. ant(x) := nil
Fim
Custo: O tempo de execuo para Insero de uma lista
com n elementos O(1).

Operaes em Lista - Remoo


Lista-Remoo (L,x) O procedimento Remoo retira
um elemento x de uma lista duplamente encadeada.
Lista-Remoo (L,x)
Incio
1. x := Lista-Busca (L,x)
2. se ant(x) nil
3. ento prox(ant(x)) := prox(x)
4. seno head(L) := prox(x)
5. se prox(x) nil
6. ento ant(prox(x)) := ant(x)
Fim
Custo: O procedimento Remoo executa em tempo (n)
Para uma lista com n elementos, isto devido ao uso de Busca.

Disciplinas de Pilha e Fila


Pilha - implementa a poltica LIFO (last-in, first-out)
Insero : incio da lista
Remoo: incio da lista
Fila - implementa a poltica FIFO (first-in,first-out)
insero : final da lista
remoo : incio da lista

Opes de implementao
1. Arrays A alocao seqencial favorvel porque inseres e remoes no acarretam movimentao de ns.
Os elementos a serem inseridos ou removidos esto
em posies especiais.
Do que voc precisa ?
Pilha - Uma varivel que mantenha o topo da lista (topo).
Fila - Duas variveis que mantenham o incio (head) e o
final da lista (tail).
Dica: Leia o tpico no livros dos autores Cormen et al.

2. Listas encadeadas
Neste caso, as operaes envolvidas so casos particulares
daquelas apresentadas anteriormente.
Pilhas
Empilhamento coloca um elto x previamente definido
(alocao realizada,campos preenchidos) na pilha.
Pilha-Insero (P,x)
Entrada: pilha P , elemento a ser inserido x.
Sada: pilha (P + x)
Incio
1. Lista-Insero (P,x)
Fim

Desempilhamento remove o elto x do topo da pilha P.


Pilha-Remoo (P)
Entrada: pilha P com elto x no topo.
Sada: pilha (P x)
Incio
1. Se head(P) = nil
2. ento {pilha vazia}
3. seno
head(P) := prox(x)
prox(x) := nil
desaloque x
Fim

Filas
Insero (F,x) insere o elto x previamente definido na fila F.
Obs: Tail um ponteiro para o ltimo elemento.
Insero (F,x)
Entrada: uma fila F, elto x para inserir
Sada: fila (F + x)
Incio
1. prox(x) := nil
2. prox(tail(F)) := x
3. tail(F) := x
Fim
Qual o tempo de execuo da operao de insero?

Filas
Remoo(F) retirar o elemento x do incio da fila F.
Remoo (F)
Entrada: uma fila F
Sada: uma fila (F x)
Incio
1. se head(F) = nil
2.
ento {fila vazia}
3.
seno apont_x = head(F)
4.
head(F) := prox(apont_x)
5.
x := elem(apont_x)
6.
desaloque(apont_x)
7.
devolva(x)
Fim
Obs: Operao de consulta para pilhas e filas so imediatas.

Exerccios
1. Faa os algoritmos para as operaes sobre listas simplesmente encadeadas e circulares.
2. Faa os algoritmos para as operaes de pilhas e filas em
arrays.

Você também pode gostar