Estrutura de Dados Pilha (Stack)

⋆ Estrutura de Dados que corresponde a uma lista sequencial com a

propriedade seguinte: LIFO –
O primeiro elemento a entrar é o último a sair (“Last in First Out”)

Operações básicas:
⋆ criar uma pilha vazia;
⋆ sobreposição de um novo elemento;
⋆ retirar o elemento do topo da pilha
⋆ verificar qual é o elemento no topo da pilha
⋆ verificar se a pilha está vazia

Representação dinâmica:
type
TipoValor = . . . ;
Pilha = ˆ Elemento;
Elemento = record
valor : TipoValor;
ant : Pilha;
end;
MP II, 2006/2007 – p.16/??
Operadores sobre Pilha

⋆ function criar : Pilha;

cria uma pilha vazia

⋆ function vazia(P:Pilha) : boolean;

devolve verdade sse a pilha P estiver vazia

⋆ procedure sobrepor(var P : Pilha; x : TipoValor)

coloca um novo elemento com x no topo da pilha P

⋆ procedure remover(var P : Pilha)

remove o elemento da cabeça da pilha P; dá erro se vazia

⋆ function topo(P:Pilha) : TipoValor;

Se a pilha P não estiver vazia, devolve o valor no elemento do topo de P ;
dá erro se vazia

MP II, 2006/2007 – p.17/??

Estrutura de Dados Fila (Queue)

⋆ Estrutura de Dados que corresponde a uma lista sequencial com a

propriedade seguinte: FIFO –
O primeiro elemento a entrar é o primeiro a sair (“First in First Out”)

Operações básicas:
⋆ criar uma fila vazia;
⋆ inserção de um novo elemento no fim;
⋆ retirar o elemento da frente da fila
⋆ verificar qual é o elemento na frente da pilha
⋆ verificar se a fila está vazia

Representação dinâmica:
type
TipoValor = . . . ;
Fila = ˆ Elemento;
Elemento = record
valor : TipoValor;
ant : Fila;
end;
MP II, 2006/2007 – p.18/??
Operadores sobre Fila

⋆ function criar : Fila;

cria uma fila vazia

⋆ function vazia(F:Fila) : boolean;

devolve verdade sse a fila F estiver vazia

⋆ procedure por(var F : Fila; x : TipoValor)

coloca um novo elemento com x no fim da fila F

⋆ procedure remover(var F : Fila)

remove o elemento da cabeça da fila F; dá erro se vazia

⋆ function frente(P:Pilha) : TipoValor;

Se a fila F tiver elementos, devolve o valor no elemento da cabeça de F;
dá erro se vazia

MP II, 2006/2007 – p.19/??

Filas e Pilhas como Estruturas Dinâmicas

⋆ Uma Pilha deve ser implementada como Lista Ligada Simples

⋆ Uma Fila deve ser implementada como Lista Ligada com Elemento Base

MP II, 2006/2007 – p.20/??

Pilha (Stack) – Estrutura LIFO

type
TipoValor = . . . ;
Lista = ˆ Elemento;
Elemento = record
valor : TipoValor;
ant : Lista;
end;
Pilha = Lista;

{* Cria uma pilha vazia *}

function criarP : Pilha;
begin
criarP := nil
end;

{* devolve TRUE sse pilha vazia *}

function vaziaP(P : Pilha): boolean;
begin
if P == nil then vaziaP := true
else vaziaP := false
end;
MP II, 2006/2007 – p.21/??
Implementação da operações para Pilha

{* cria novo elemento Elemento, inicializa e devolve apontador *}

function cria_elem(val : TipoValor) : Lista;
var aux : Lista;
begin
new(aux);
with auxˆ do
begin
valor := val;
prox := nil;
end;
cria_elem := aux;
end;

{* cria e coloca novo elemento no topo de p = INSERE NA CABECA *}

. . .

MP II, 2006/2007 – p.22/??

Implementação da operações para Pilha– continuação

{* remove elemento do topo de P = REMOVE A CABECA *}

Procedure remover(var P : Pilha)
var aux : Pilha;
begin
if not vaziaP(P)
then begin
aux := P;
P := Pˆ.prox ;
dispose(aux);
end
else
writeln(’**** ERRO: Tentativa de remover de pilha vazia’);
end;

MP II, 2006/2007 – p.23/??

Continuação da continuação

{* devolve o valor do elemento no topo de p *}

procedure topo(P Pilha; var val : TipoValor);
begin
if not vaziaP(P)
then val := pˆ.valor;
else begin
writeln(’**** ERRO: Tentativa de consultar pilha vazia’)
val := valor_vazio;
end
end;

MP II, 2006/2007 – p.24/??

FILA (Queue) – Estrutura FIFO

TipoValor = . . . ;
Lista = ˆ Elemento;
Elemento = record
valor : TipoValor;
ant : Lista;
end;
Fila = ˆrecord
inicio : Lista;
fim : Lista;
end;

{* Cria uma fila vazia *}

function criarF : Fila;
var aux : Fila;
begin
new(aux);
with auxˆ do begin
inicio := nil;
fim := nil;
end;
criarF := aux;
end;
MP II, 2006/2007 – p.25/??
Implementação da operações para FILA

{* devolve TRUE sse fila vazia *}

function vaziaP(F : Fila): boolean;
begin
if Fˆ.inicio == nil then vaziaF := true
else vaziaF := false
end;

{* INSERE NO FIM COM PONTEIRO AUXILIAR *}

Procedure por(val : TipoValor; var F : Fila)
var novo : Lista;
begin
novo := cria_elem(val);
if vaziaF(F)
then Fˆ.inicio := novo;
else Fˆ.fimˆ.prox := novo;
Fˆ.fim := novo;
end;

MP II, 2006/2007 – p.26/??

Implementação da operações para FILA– continuação

{* remove elemento da frente de F = REMOVE A CABECA *}

Procedure remover(var F : Fila)
var aux : Lista;
begin
if not vaziaF(F)
then begin
aux := Fˆ.inicio;
F := auxˆ.prox;
dispose(aux);
if vaziaF(F)
then Fˆ.fim := nil; { se este era o ultimo elemento }
end
else
writeln(’**** ERRO: Tentativa de remover de fila vazia’);
end;

MP II, 2006/2007 – p.27/??

Continuação da continuação

{* devolve o valor do elemento no topo de p *}

procedure topo(F : Fila; var val : TipoValor);
begin
if not vaziaF(F)
then val := Fˆ.inicioˆ.valor;
else begin
writeln(’**** ERRO: Tentativa de consultar Fila vazia’);
val := valor_vazio;
end
end;

MP II, 2006/2007 – p.28/??