1

Listas Duplamente Encadeadas !  quando for preciso seguir a seqüência de elementos em

ambos os sentidos !  cada nó possui dois ponteiros: ant e prox

Fim

a b c d

Início

prox ant

2

Listas Duplamente Encadeadas - Operações

!  um conjunto maior de ligações a serem atualizadas

!  necessário especificar mais um ponteiro ant no algoritmo?

!  Especificar o algoritmo de !  inserção !  remoção

3

Listas Circulares

!  tanto para simplesmente quanto duplamente encadeadas

!  útil quando !  quando se busca a partir de qualquer elemento !  não há ordenação na lista

!  um ponteiro para algum elemento deve estar sempre definido

4

!  Para muitas aplicações é necessário impor restrições de acesso aos dados !  essas restrições podem vir a ser benéficas por:

!  aliviar a necessidade de usar estruturas com mais detalhes !  permitem implementações mais simples e flexíveis, desde que

menos operações são suportadas

!  pilhas - LIFO: last in first out !  filas - FIFO: first in first out

Estruturas de Acesso Restrito

!  Apenas duas operácões básicas estão envolvidas: !  PUSH ou Empilha: Acrescentar no topo da pilha

!  POP ou Desempilha: Retirar do topo da pilha

1o. elem. 2o. elem. 3o. elem.

1o. elem. 2o. elem. 3o. elem. 4o. elem.

1o. elem. 2o. elem. 3o. elem.

Pilhas

6

Pilhas !  A política de inserção e remoção à maneira

de uma pilha é também conheciada como LIFO: Last In, First Out

7

Pilhas em Lista Sequenciais

!  PILHA - lista sequencial que implementa pilha !  o elemento 0 será definido como o fundo da pilha !  topo da pilha: TOPO é o índice que indica a 1a.

posição livre da pilha P !  pilha vazia: TOPO = 0 !  restrição: tamanho máximo

1o. elem. 2o. elem. 3o. elem. 4o. elem.

4

8

Pilhas - Lista Sequenciais iniciapilha(){

Topo = 0 /* Pilha vazia */ } empilha (x)‏

if(topo < MAX) { /* Possui espaço */ PILHA[topo] = x; Topo ++; return(true); } else return(false); /* estouro da pilha */

9

Pilhas - Lista Sequenciais #define VAZIA 9999999 desempilha (){

if(Topo != 0) { /* Possui elemento na pilha */ Topo - -; return(PILHA[topo]); } else return(VAZIA); /* pilha vazia */

}

10

Pilhas - Lista Sequenciais "  consultar o tamanho atual da pilha altura (PILHA) { return (Topo-1); }

"  consultar o topo da pilha

topo (PILHA) { return(PILHA[Topo-1]); }

11

Complexidade das Operações em Pilha em Lista Sequenciais

!  Todas as operações são O(1)‏ !  Se for necessário tratar overflow com

realocação, inserção pode ter complexidade de pior caso O(n)‏ !  Uma nova lista de comprimento maior seria alocada !  Todos os elementos são copiados para a nova lista

12

!  Topo – agora é um ponteiro para o topo da pilha !  Pilha vazia: Topo= NULL

!  não possui restrição de tamanho máximo

Pilhas em lista encadeada

13

Pilhas - lista encadeada !  empilha

!  desempilha

novo elemento

14

Pilhas - lista encadeada inic_pilha()‏ {

Topo = NULL; }

empilha (valor)‏ {

??

}

15

Pilhas - lista encadeada desempilha ()‏ { t = Topo; if (t == NULL) /* pilha vazia */ return( “vazia”)‏ else {

} }

16

Pilhas - exercício !  um algoritmo que converta uma expressão

aritmética da forma parentizada para pós-fixa

!  Forma parentizada: 5 *) )) 9+8 ( * ) 4*6 ( (+ 7(‏ !  Forma pós-fixa: 5 9 8 + 4 6 * * 7 + *

17

Filas

!  Seja F uma fila, e v um valor: !  enfila (v): v é inserido no final da fila F !  desenfila(): descarta o elemento mais antigo da fila F,

ou seja, o elemento que está no início de F !  comprimento(F): retorna o número de elementos na

fila F

!  A política de inserção e remoção de dados à maneira de uma fila é conhecida como FIFO – First In First Out

18

Filas

5o. elem. 4o. elem. 3o. elem. 2o. elem. 1o. elem.

6o. elem. 5o. elem. 4o. elem. 3o. elem. 2o. elem. 1o. elem.

6o. elem.

"  enfila: respeitar o tamanho máximo da lista "  desenfila: pode esvaziar a fila

19

Filas

5o. elem. 4o. elem. 3o. elem. 2o. elem. 1o. elem.

6o. elem. 5o. elem. 4o. elem. 3o. elem. 2o. elem. 1o. elem.

6o. elem. •  enfila 3o •  enfila 4o •  desenfila

•  desenfila •  enfila 5o

20

Filas

5o. elem. 4o. elem. 3o. elem. 2o. elem. 1o. elem.

6o. elem.

•  enfila 6o

21

enfila(v)‏ { if (mod(Fim+1, MAX) != Início ){

F[Fim]=v; Fim = mod(Fim+1, MAX); }else “overflow”; }

Filas

desenfila(){ if( Início != -1){

valor=F[Início]; Início=mod(Início +1,MAX);

if (Inicio == Fim)‏ Inicio = Fim = -1;

} else “underflow”; }

Filas lista encadeada

23

Filas lista encadeada

!  Após a inserção do 1o. elemento

Inicialização : "  inicio = NULL; fim = NULL;

24

Filas lista encadeada – inserção enfila_enc (v){

}

25

Filas lista encadeada desenfila_enc(){

}

26

Filas e Pilhas Múltiplas !  Alocar mais de um pilha ou fila em uma mesma região de

memória !  implementação por listas sequenciais !  Duas pilhas

!  simples : uma cresce de cada lado da lista !  Mais de duas pilhas

!  dividir a área em tamanhos proporcionais aos tamanhos máximos das pilhas ou, se não souber, em pedaços iguais.

27

Filas E Pilhas Múltiplas

Área de Memória

28

Filas E Pilhas Múltiplas

!  Especificar os algoritmos de inserção e remoção em pilha, considerando duas pilhas armazenadas em lista sequencial que compartilham a memória de dimensão M