Cap4pilhasfilas 111028194635 Phpapp01

Pilhas e filas
Estudo de listas lineares especiais, com disciplina restrita

de organização e de acesso a seus nodos
Estruturas de Dados 1
Pilhas e filas
Listas lineares especiais
Com disciplina restrita de organização e

acesso a seus nodos
Disciplina restrita
acesso permitido somente em alguns
nodos
Pilhas e filas
Listas lineares especiais mais usuais
LIFO Last In First Out

o último componente inserido Pilha
é o primeiro a ser retirado
FIFO First In First Out

o primeiro componente inserido Fila
é também o primeiro a ser retirado
Exclusões Inserções
Pilhas e Filas Consultas
Topo
PILHA
Base
FILA
Exclusões Início Final

e
Consultas Inserções
Filas Duplas
inserções exclusões
exclusões inserções
Inserções e exclusões podem ocorrer em qualquer extremidade da lista

• Especialização de fila
Pilhas e filas
Pilhas
Pilhas
Operações sobre Pilhas

Consultas
Topo
• Criar uma pilha vazia
• Inserir um nodo no topo da pilha
• Remover o nodo do topo de pilha
• Consultar / modificar nodo do topo da pilha
• Destruir a pilha Base
Pilhas
Pilhas implementadas por contiguidade física
Pilha – contiguidade física
Pilha - contiguidade física Lim
• Implementada sobre um arranjo Topo
• Índices de controle da pilha:

• BASE da pilha
• TOPO atual da pilha
• LIMITE máximo que pode ser ocupado pela pilha
Base
Pilha
Índices
do arranjo
Exemplo de manipulação de uma pilha

1. Inicializar pilha de valores inteiros, a partir do índice 1, máximo 10 nós
2. Inserir nodo com valor 3
5. Remover nodo do topo
6. Consultar pilha Retorna “7”
LIM 10 LIM 10 LIM 10 LIM 10 LIM 10

9 9 9 9 9
8 8 8 8 8
7 7 7 7 7
6 6 6 6 6
5 5 5 5 5
4 4 4 4 4
TOPO 5
3 3 3 3 3
TOPO 7 7 TOPO 7
BASE 2 BASE 2 BASE 2 BASE 2 BASE 2
TOPO
3 3 3 3
1 1 1 1 1
TOPO
PILHA PILHA PILHA PILHA PILHA
Operações
• Criar uma pilha vazia

• Inserir um nodo no topo da pilha
• Remover o nodo do topo de pilha
• Consultar / modificar nodo do topo da pilha
Tipo de dados utilizado nos algoritmos para pilha implementada

por contiguidade física:
TipoPilha = arranjo [1..N] de TipoNodo
Criação da pilha
Lim 10
9
1. Definir valor do índice de BASE da pilha 8
2. Definir valor máximo de nodos que a pilha pode ter  LIM 7
3. Indicar que a pilha está vazia através do valor de TOPO 6
5
Exemplo: 4
3
Base ← 1 2
Topo ← Base – 1 Base 1
Lim ← 6 Topo
Pilha
Algoritmo:
Inicializar Pilhas implementada sobre Arranjo
Algoritmo 4.1 - InicializarPilhaArr

Entrada: Base (inteiro)
Saída: Topo (inteiro)
início
Topo ← Base – 1
fim
Inserção de um nodo na pilha
Operação PUSH
Lim 10 Lim 10
9 9
8 8
7 7
6 6
5 5
4 Topo 4
Topo
3 3
2 2
Base 1 Base 1
Pilha Pilha
Algoritmo:
Inicializar Pilhas implementada sobre Arranjo
Algoritmo 4.2 - InserirPilhaArr
Entradas: Pilha (TipoPilha)
Lim (inteiro)
Topo (inteiro)
Valor (TipoNodo)
Saídas: Pilha (TipoPilha)
Topo (inteiro)
Sucesso (lógico)
início
se Topo < Lim
então início
Topo ← Topo + 1
Pilha[Topo] ← Valor
Sucesso ← verdadeiro
fim
senão Sucesso ← falso
fim
Remoção de um nodo da pilha

Operação POP
Lim 10 Lim 10
9 9
8 8
7 7
6 6
Topo 5 5
4 Topo 4
3 3
2 2
Base 1 Base 1
Pilha Pilha
Algoritmo: Remover nodo do topo de Pilha
implementada sobre Arranjo
Algoritmo 4.3 - RemoverPilhaArr
Topo (inteiro)
Base (inteiro)
Saídas: Pilha (TipoPilha)
Topo (inteiro)
Sucesso (lógico)
ValorRemovido (TipoNodo)
início
se Topo ≥ Base
então início
ValorRemovido ← Pilha[Topo]
Topo ← Topo - 1
fim
fim
Acesso à pilha
Lim 10
9
• Somente ao nodo do topo da pilha 8
7
• Para consulta e/ou modificação
6
5
Topo ? 4
3
2
Base
1
Pilha
Algoritmo: Consultar nodo do topo de Pilha
Algoritmo 4.4 - ConsultarPilhaArr

Base (inteiro)
Topo (inteiro)
Saídas: Valor (TipoNodo)
Sucesso(lógico)
início
se Topo ≥ Base
então início
Valor ← Pilha[Topo]
fim
fim
Pilhas
Pilhas implementadas por encadeamento
Pilha implementada por encadeamento
remoções
Endereço do topo da inserções
PtPilha pilha ?
consultas
Info Elo Topo
Topo da pilha
Base
Tipo de dados utilizado nos algoritmos:

TipoNodo = registro
Base da pilha Info: TipoInfo
Elo: TipoPtNodo
fim registro
Pilha por encadeamento
Criação de pilha encadeada
• Pilha criada vazia
• Atribuir endereço nulo para apontador que contém o

endereço do topo da pilha
Algoritmo: Criar Pilha Encadeada
Algoritmo 4.5 - CriarPilhaEnc

Entradas: -
Saída: PtPilha (TipoPtNodo)
início
PtPilha ← nulo
fim
Inserção de um nodo em pilha encadeada

• Novo nodo inserido sempre no topo da pilha
PtPilha PtPilha
Topo Novo
nodo
Topo
Topo
Base Base
Algoritmo: Inserir nodo em Pilha Encadeada
Algoritmo 4.6 - InserirPilhaEnc

Entradas: PtPilha (TipoPtNodo)
Valor (TipoInfo)
Variável local: PtNovo (TipoPtNodo)
início
alocar(PtNovo)
PtNovo↑.Info ← Valor
PtNovo↑.Elo ← PtPilha
PtPilha ← PtNovo
fim
Remoção de um nodo de uma pilha encadeada
• Só pode ser removido o nodo do topo da pilha
PtPilha Nodo a ser

removido
PtPilha
Topo
Topo
Base Base
Algoritmo: Remover nodo de Pilha Encadeada
Algoritmo 4.7 - RemoverPilhaEnc

Entrada: PtPilha (TipoPtNodo)
Saídas: PtPilha (TipoPtNodo)
Sucesso (lógico)
Variável local: PtAux (TipoPtNodo)
início
se PtPilha ≠ nulo
então início
PtAux ← PtPilha
PtPilha ← PtPilha↑.Elo
liberar(PtAux)
fim
fim
Acesso à pilha encadeada
• Só pode ser acessado o nodo do topo da pilha
PtPilha Nodo que pode ser

acessado
Topo
Base
Algoritmo:
Consultar nodo do topo de Pilha Encadeada
Algoritmo 4.8 - ConsultarPilhaEnc

Saídas: Valor (TipoInfo)
Sucesso (lógico)
início
se PtPilha = nulo
então Sucesso ← falso
senão início
Valor ← PtPilha↑.Info
fim
fim
Algoritmo: Desempilhar
Consulta nodo do topo da pilha, e o remove da pilha
Algoritmo 4.9 - Desempilhar
Saídas: PtPilha (TipoPtNodo)
Valor (TipoInfo)
Sucesso (lógico)
início
se PtPilha = nulo
senão início
Valor ← PtPilha↑.Info
PtAux ← PtPilha
liberar(PtAux)
fim
fim
Destruição de uma pilha encadeada
• Liberar espaço ocupado pelos nodos, sempre a partir do topo da pilha

• No final: apontador para o topo = endereço nulo
PtPilha
Topo
PtPilha
Topo
PtPilha
Topo
Topo
Base Base Base Base PtPilha = nil
Algoritmo: Destruir Pilha Encadeada
Algoritmo 4.10 - DestruirPilhaEnc

início
enquanto PtPilha ≠ nulo
faça início
PtAux ← PtPilha
liberar(PtAux)
fim
fim
Pilhas e filas
Filas
Filas
Filas
Início Final
Inserções
Exclusões
e
Consultas
Operações válidas:
• Criar uma fila vazia
• Inserir um nodo no final da fila
• Excluir o nodo do início da fila
• Consultar / modificar nodo do início da fila
• Destruir a fila
Filas
Filas implementadas por contiguidade física
Fila por contiguidade
Fila implementada sobre arranjo
Exclusões
e
Consultas
Inserções
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
LI : limite inferior da área

Fila vazia
IF : início da fila
FF : final da fila IF = 0
LS : limite superior da área
Evolução da Fila
1 2 3 4 5 6
FILA
LI=IF=FF LS
1 2 3 4 5 6
FILA 3
2. Inicializar a fila
LI=IF FF LS
3. Inserir um novo nodo com valor 3 1 2 3 4 5 6
4. Inserir um novo nodo com valor 7 FILA

3 7
5. Inserir um novo nodo com valor 5
LI=IF FF LS
1 2 3 4 5 6
6. Remover um nodo
FILA 3 7 5
LI IF FF LS
1 2 3 4 5 6
FILA
7 5
Ocupação circular do arranjo
IF
LI FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
FF
LI IF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
LI FF IF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
Operações sobre Filas

implementadas por contiguidade

Tipo de dados utilizado nos algoritmos para fila implementada

por contiguidade física:
TipoFila = arranjo [1..N] de TipoNodo
Criação de uma fila
• Inicializar variáveis que controlam início e final da fila e início

e final da área disponível para a fila
FF
... IF LI LS
...
FILA
Espaço disponível para a fila
Algoritmo:
Inicializar Fila implementada sobre Arranjo
Algoritmo 4.11 - InicializarFilaArr

Entrada: LI (inteiro)
Saídas: IF, FF (inteiros)
início
IF ← FF ← LI – 1
fim
Inserção de um nodo em uma fila
• Nodo inserido sempre no final da fila
Testar se tem espaço livre para inserir:
IF
LI FF LS
... ... atrás
FF
LI IF LS
... ... na frente
LI FF IF LS
... ... no meio
Algoritmo: Inserir um nodo em uma Fila implementada
sobre Arranjo
Algoritmo 4.12 - InserirFilaArr
Entradas: Fila (TipoFila)
LI, LS, IF, FF (inteiros)
Info (TipoNodo)
Sucesso (lógico)
início
se (FF ≠ IF - 1) e ((IF ≠ LI) ou (FF ≠ LS))
então início
se IF = LI - 1
então IF ← FF ← LI {INSERÇÃO DO PRIMEIRO NODO}
senão se FF = L
então FF ← LI {INSERÇÃO NO INÍCIO}
senão FF ← FF + 1 {INSERÇÃO NO MEIO OU ATRÁS}
FILA[FF] ← Info
fim
fim
Remoção de um nodo de uma fila
• Nodo removido é sempre o do início da fila
Nodo que pode ser

removido
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
FILA
Algoritmo: Remover um nodo de uma Fila implementada
sobre Arranjo
Algoritmo 4.13 - RemoverFilaArr
Entradas: LI, LS, IF, FF (inteiros)
Sucesso (lógico)
início
se IF ≠ LI - 1
então início
se IF = FF
então IF ← FF ← LI - 1 {FILA FICA VAZIA}
senão se IF = LS
então IF ← LI
senão IF ← IF + 1
fim
fim
Acesso à fila
• Só o nodo do início da fila pode ser acessado

• Acesso para consulta e/ou alteração
Nodo que pode ser

acessado
LI IF FF LS
... ? ...
Algoritmo:
Consultar Fila implementada sobre Arranjo
Algoritmo 4.14 - ConsultarFilaArr

Entradas: Fila (TipoFila)
LI, IF (inteiros)
Saídas: Info (TipoNodo)
Sucesso (lógico)
início
se IF ≠ LI - 1
então início
Info ← Fila[IF]
fim
fim
Filas
Filas implementadas por encadeamento
Filas por encadeamento
Filas implementadas por encadeamento

Tipo de dados para nodos da fila:
Frente Final
TipoNodo = registro
Info: TipoInfo
Elo: TipoPtNodo e
fim registro Consultas
Endereço do primeiro da
fila, para remoção
PtFila
Endereço do final da fila,
para inserção
Info Elo
F1 F2 F3 Fn
Para acessar o último nodo, é necessário percorrer

toda a fila a partir do primeiro nodo
Filas por encadeamento com descritor
Descritor Tipo de dados para o descritor da fila:

Prim: primeiro da fila
TipoDFila = registro
Ult : último da fila
Prim: TipoPtNodo
Ult: TipoPtNodo
fim registro
TipoPtDFila = ↑TipoDFila
PtDF
Prim Ult
L1 L2 L3 L4
Operações sobre Filas implementadas por

encadeamento com descritor

• Destruir a fila
Criação da fila encadeada
• Alocar o descritor da fila

• Descritor inicializado em endereços nulos
• Fila vazia
PtDF
Prim Ult
Algoritmo:
Criar Fila Encadeada endereçada por descritor
Algoritmo 4.15 - CriarFilaEnc

Entradas: -
Saída: PtDFila (TipoPtDFila)
início
alocar(PtDFila)
PtDFila↑.Prim ← nulo
PtDFila↑.Ult ← nulo
fim
Inserção de um nodo na fila encadeada

PtDFila Prim Ult
PtDFila
Prim Ult
/
PtDFila PtDFila
Prim Ult Prim Ult
Algoritmo:
Inserir novo nodo em Fila Encadeada
endereçada por descritor
Algoritmo 4.16 - InserirFilaEnc

Entradas: PtDFila (TipoPtDFila)
Valor (TipoInfo)
Saídas: -
Variável auxiliar: PtNovo (TipoPtNodo)
início
alocar(PtNovo)
PtNovo↑.Elo ← nulo
se PtDFila↑.Prim = nulo
então PtDFila↑.Prim ← PtNovo
senão (PtDFila↑.Ult)↑.Prox ← PtNovo
PtDFila↑.Ult ← PtNovo
fim
Remoção de um nodo de fila encadeada
PtDFila Prim Ult

PtDFila Prim Ult
/
/
PtDFila Prim Ult

PtDFila Prim Ult
Algoritmo:
Remover um nodo de Fila Encadeada
endereçada por descritor
Algoritmo 4.17 - RemoverFilaEnc
Entrada: PtDFila (TipoPtDFila)
Saída: Sucesso (lógico)
Variável auxiliar: PtAux (TipoPtNodo)
início
se PtDFila↑.Prim ≠ nulo
então início
PtAux ← PtDFila↑.Prim
PtDFila↑.Prim ← PtAux↑.Elo
liberar(PtAux)
se PtDFila↑.Prim = nulo
então PtDFila↑.Ult ← nulo
fim
fim
Remoção de um nodo de fila encadeada
• Só o nodo do início da fila pode ser acessado

• Acessado diretamente pelo endereço no descritor
PtDFila Prim Ult
? /
Algoritmo:
Consultar Fila Encadeada endereçada por descritor
Algoritmo 4.18 - ConsultarFilaEnc

Saídas: Valor (TipoInfo)
Sucesso (lógico)
início
então início
Valor ← PtDFila↑.Prim↑.Info
fim
fim
Destruição de fila encadeada
PtDFila Prim Ult

Liberar
posições
ocupadas pela
/ lista
PtDFila Prim Ult Liberar

descritor
PtDFila = nulo
Algoritmo:
Destruir Fila Encadeada endereçada por descritor
Algoritmo 4.19 - DestruirFilaEnc
Saída: PtDFila (TipoPtDFila)
Variáveis auxiliares: P1, P2 (TipoPtNodo)
início
então início
P1 ← PtDFila↑.Prim
repita
P2 ← P1↑.Elo
liberar(P1)
P1 ← P2
até P1 = nulo
fim
liberar(PtDFila)
PtDFila ← nulo
fim
Filas
Fila dupla - Deque
Fila dupla
Fila dupla - Deque
I ns s
erç õe
õ es rç
Final In se
Início
Consultas Consultas
s Exc
sõe lus
ões
Ex clu
• Inserção, remoção e acesso às duas extremidades
Fila dupla
Fila dupla - Deque
Operações válidas:
• Criar uma fila dupla vazia
• Inserir um nodo no início
• Inserir um nodo no fim
• Excluir um nodo do início
• Excluir um nodo do fim
• Consultar / modificar nodo do início ou do fim
• Destruir a fila dupla
Fila dupla
Fila dupla implementada por contiguidade física
Fila dupla por contiguidade
Fila dupla implementada sobre arranjo

I ns
erç rç ões
LI : limite inferior da área no arranjo
ões
Início Final I nse
IF : início da fila Consultas Consultas

FF : final da fila es Exc
õ lus
LS : limite superior da área disponível xc lus õ es
E
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
Deque
Tipo de dados para fila dupla por contiguidade:
TipoFila = arranjo [1..N] de TipoNodo
Criação de uma fila dupla
• Inicializar indicadores de início e final da fila

dupla
• Fila criada vazia
FF
IF LI LS
0 1 2 3 4 5 6 7 8 9 10 12 13 14
Deque
Algoritmo:
Inicializar Deque implementada sobre Arranjo
Algoritmo 4.20 - InicializarDequeArr

Entrada: LI (inteiro)
início
IF ← FF ← LI – 1
fim
Inserção de um nodo em uma fila dupla
• A inserção pode ser feita em qualquer uma das duas extremidades

• Definir em qual extremidade deve ser inserido o novo nodo
• Ocupação circular do arranjo
Início Final
Inserção Inserção
Inserção no final
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
Ocupação circular do arranjo:

FF
LI IF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
FF
LI IF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
Inserção no início
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
LI IF FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
Ocupação circular do arranjo:

IF
LI FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
IF
LI FF LS
1 2 3 4 5 6 7 8 9 10 12 13 14
DEQUE
Algoritmo: Inserir um nodo no Início de Deque
Algoritmo 4.21 - InserirIniDequeArr
Entrada: Deque (TipoDequeArr)
LI, LS, IF, FF (inteiros)
Info (TipoNodo)
Saídas: Deque (TipoDequeArr)
IF, FF (inteiros)
Sucesso (lógico)
início
se ((FF = IF - 1) ou ((IF = LI) e (FF = LS)))
senão início
se IF = LI – 1 {DEQUE VAZIA}
então IF ← FF ← LI
senão se IF > LI
então IF ← IF – 1
senão IF ← LS
Deque[IF] ← Info
fim
fim
Remoção de um nodo de uma fila dupla
• A remoção pode ser feita em qualquer uma das duas extremidades

• Definir de qual extremidade deve ser removido o novo nodo
Início Final
Remoção Remoção
Algoritmo: Remover o nodo do Fim da Deque
Algoritmo 4.22 - RemoverFimDequeArr
Entradas: LI, LS, IF, FF (inteiros)
Sucesso (lógico)
início
se IF ≠ LI – 1
então início
se IF = FF {DEQUE VAI FICAR VAZIA}
então IF ← FF ← LI - 1
senão se FF = LI
então FF ← LS
senão FF ← FF - 1
fim
fim
Acesso a uma fila dupla
• Somente os nodos das duas extremidades podem ser acessados
Início Final
Acesso Acesso
Algoritmo: Consultar qual o Maior valor contido nas
extremidades de uma Deque implementada sobre Arranjo
Algoritmo 4.23 - ConsultarMaiorDequeArr

Entradas: Deque (TipoDequeArr)
LI, IF, FF (inteiros)
Saída: MaiorValor (inteiro)
início
se IF = LI - 1
então MaiorValor ← 0
senão se Deque[IF] > Deque[FF]
então MaiorValor ← Deque[IF]
senão MaiorValor ← Deque[FF]
fim
Fila dupla
Fila dupla implementada por contiguidade física
Fila dupla por encadeamento
Fila dupla implementada por encadeamento
Exclusões Exclusões
Inserções Inserções
Acesso Acesso
Início
PtFilaDupla
Final
F1 F2 F3 Fn
Para acessar o último nodo, é necessário percorrer

toda a lista a partir do primeiro nodo
Fila dupla encadeada com descritor
PtDFD
Prim Ult
Na remoção do último nodo, precisa atualizar descritor

que passará a apontar para o penúltimo – percorrer a
fila do início para chegar ao penúltimo
Fila dupla – duplo encadeamento e descritor

PtDFD Descritor
Prim Ult
Prim: primeiro da fila
Ult : último da fila
Ant Info Prox
Tipo de dados para nodos da fila dupla:

TipoNodo = registro
Tipo de dados para o Ant: TipoPtNodo
descritor da fila dupla: Info: TipoInfoNodo
Prox: TipoPtNodo
TipoDDeque = registro fim registro
Prim: TipoPtNodo
Ult: TipoPtNodo
fim registo
TipoPtDDeque = ↑TipoDDeque
Criação de fila dupla encadeada
• Alocação do descritor
• Inicialização do descritor para fila dupla vazia
PtDFD
Prim Ult
Algoritmo:
Criar Deque implementada por Encadeamento
Algoritmo 4.24 - CriarDequeEnc

Entradas: -
Saída: PtDDeque (TipoPtDDeque)
início
alocar(PtDDeque)
PtDDeque↑.Prim ← PtDDdeque↑.Ult ← nulo
fim
Inserção de um novo nodo
PtDFD
Prim Ult
PtDFD ício
Prim Ult No in N A B C
No
fina
l
PtDFD
A B C Prim Ult
A B C N
Algoritmo: Inserir nodo em Deque Encadeada

Algoritmo 4.25 - InserirDequeEnc
Entradas: PtDeque (TipoPtDeque)
Lado (caractere)
Valor (TipoInfoNodo)
var PtNovo (TipoPtNodo)
início
Sucesso ← falso
se (Lado = “I”) ou (Lado = “F”)
então início
alocar(PtNovo)
se Lado = “I”
{ então início {INSERE NO INÍCIO} SEGUE }
Algoritmo (cont): Inserir nodo em Deque Encadeada
então início {INSERE NO INÍCIO}
PtNovo↑.Ant ← nulo
se PtDDeque↑.Prim = nulo
então início
PtDDeque↑.Ult ← PtNovo
PtNovo↑.Prox ← nulo
fim
senão início
PtNovo↑.Prox ← PtDDeque↑.Prim
(PtDDeque↑.Prim)↑.Ant ← PtNovo
fim
PtDDeque↑.Prim ← PtNovo
fim
senão início {INSERE NO FINAL}
PtNovo↑.Prox ← nulo
se PtDDeque↑.Prim = nulo
então início
PtNovo↑.Ant ← nulo
PtDDeque↑.Prim ← PtNovo
fim
senão início
(PtDDeque↑.Ult)↑.Prox ← PtNovo
PtNovo↑.Ant ← PtDDeque↑.Ult
fim
PtDDeque↑.Ult ← PtNovo
fim
fim
fim
Remoção de um nodo
PtDFD
Prim Ult
PtDFD
X A B C Do Prim Ult
in íc
io
PtDFD
f i nal
Prim Ult Do
A B C
A B C X
Algoritmo: Remover nodo de Deque Encadeada
Algoritmo 4.26 - RemoverDequeEnc

Entradas: PtDDeque (TipoPtDDeque)
Lado (caractere)
var PtAux, PtAnt (TipoPtNodo);
início
Sucesso ← falso
se (PtDDeque↑.Prim ≠ nulo) e ((Lado = “I”) ou (Lado =
“F”))
então início
se Lado = “I”
{ então início {REMOVE O PRIMEIRO} SEGUE }
Algoritmo (cont.): Remover nodo de Deque Encadeada
então início {REMOVE O PRIMEIRO}
PtAux ← PtDDeque↑.Prim
se PtDDeque↑.Prim = PtDDeque↑.Ult
então PtDDeque↑.Prim ← PtDDeque↑.Ult ← nulo
senão início
PtDDeque↑.Prim ← PtAux↑.Prox
(PtDDeque↑.Prim)↑.Ant ← nulo
fim
fim
senão início {REMOVE O ÚLTIMO}
PtAux ← PtDDeque↑.Ult
se PtDDeque↑.Prim = PtDDeque↑.Ult
então PtDDeque↑.Prim ← PtDDeque↑.Ult ← nulo
senão início
PtDDeque↑.Ult ← PtAux↑.Ant
(PtDDeque↑.Ult)↑.Prox ← nulo
fim
fim
liberar(PtAux)
fim
fim
Acesso a fila dupla encadeada
Início Final
Acesso Acesso
• Podem ser acessados o primeiro e último nodo

• Endereços diretamente no descritor
PtDFD
Prim Ult
X A B C
Algoritmo:
Consultar Deque implementada por Encadeamento
Algoritmo 4.27 - ConsultarDequeEnc
Entradas: PtDDeque (TipoPtDDeque)
Lado (caractere)
Saídas: Valor (TipoInfoNodo)
Sucesso (lógico)
início
Sucesso ← falso
se (PtDDeque↑.Prim ≠ nulo) e ((Lado = “I”) ou (Lado = “F”))
então início
se Lado = “I”
então Valor ← (PtDDeque↑.Prim).Info
senão Valor ← (PtDDeque↑.Ult).Info;
fim
fim

Cap4pilhasfilas 111028194635 Phpapp01

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Cap4pilhasfilas 111028194635 Phpapp01

Caricato da

Copyright:

Formati disponibili

Pilhas e filas

Estudo de listas lineares especiais, com disciplina restrita

Listas lineares especiais

Com disciplina restrita de organização e

Listas lineares especiais mais usuais

LIFO Last In First Out

FIFO First In First Out

é também o primeiro a ser retirado

Exclusões Início Final

Inserções e exclusões podem ocorrer em qualquer extremidade da lista

Operações sobre Pilhas

Pilhas implementadas por contiguidade física

Pilha - contiguidade física Lim

• Implementada sobre um arranjo Topo

• Índices de controle da pilha:

Exemplo de manipulação de uma pilha

LIM 10 LIM 10 LIM 10 LIM 10 LIM 10

• Criar uma pilha vazia

Tipo de dados utilizado nos algoritmos para pilha implementada

TipoPilha = arranjo [1..N] de TipoNodo

Algoritmo 4.1 - InicializarPilhaArr

Remoção de um nodo da pilha

Algoritmo 4.4 - ConsultarPilhaArr

Pilhas implementadas por encadeamento

Info Elo Topo

Tipo de dados utilizado nos algoritmos:

Criação de pilha encadeada

• Pilha criada vazia

• Atribuir endereço nulo para apontador que contém o

Algoritmo: Criar Pilha Encadeada

Algoritmo 4.5 - CriarPilhaEnc

Inserção de um nodo em pilha encadeada

Algoritmo: Inserir nodo em Pilha Encadeada

Algoritmo 4.6 - InserirPilhaEnc

Remoção de um nodo de uma pilha encadeada

• Só pode ser removido o nodo do topo da pilha

PtPilha Nodo a ser

Algoritmo: Remover nodo de Pilha Encadeada

Algoritmo 4.7 - RemoverPilhaEnc

Acesso à pilha encadeada

• Só pode ser acessado o nodo do topo da pilha

PtPilha Nodo que pode ser

Algoritmo 4.8 - ConsultarPilhaEnc

Destruição de uma pilha encadeada

• Liberar espaço ocupado pelos nodos, sempre a partir do topo da pilha

Base Base Base Base PtPilha = nil

Algoritmo: Destruir Pilha Encadeada

Algoritmo 4.10 - DestruirPilhaEnc

Filas implementadas por contiguidade física

Fila implementada sobre arranjo

LI : limite inferior da área

LS : limite superior da área

4. Inserir um novo nodo com valor 7 FILA

Operações sobre Filas

• Criar uma fila vazia

Tipo de dados utilizado nos algoritmos para fila implementada

TipoFila = arranjo [1..N] de TipoNodo

Criação de uma fila

• Inicializar variáveis que controlam início e final da fila e início

Espaço disponível para a fila

Algoritmo 4.11 - InicializarFilaArr

Inserção de um nodo em uma fila

• Nodo inserido sempre no final da fila