Pilhas Filas e Listas Pilha

LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Pilhas Filas e Listas
Sumário
z Pilha: interface, aplicações e implementação
z Fila: interface, aplicações e implementação
z Lista Ligada: interface, aplicações e implementação
PFL
Pilha
‰
Estrutura LIFO (last in, first out)
z Acesso restrito ao último elemento inserido
‰
Operações
z Inserir:
push
z Remover: pop
z Pesquisar: top
push
pop
top
PFL
Cristina Ribeiro
Estruturas Lineares 1
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Interface
//
//
//
//
//
//
//
//
//
//
//
Stack interface
******************PUBLIC OPERATIONS*********************
void push( x )
--> Insert x
void pop( )
--> Remove most recently inserted item
Object top( )
--> Return most recently inserted item
Object topAndPop( )
--> Return and remove most recent item
boolean isEmpty( )
--> Return true if empty; else false
void makeEmpty( )
--> Remove all items
******************ERRORS********************************
top, pop, or topAndPop on empty stack
public interface Stack
{
boolean isEmpty( );
Object top( )
throws Underflow;
void
pop( )
throws Underflow;
Object topAndPop( ) throws Underflow;
void
push( Object x );
void
makeEmpty( );
}
PFL
Class Stack em java.util
§3.8 Class Stack
public class java.util.Stack
extends java.util.Vector (I-§3.10)
{
// Constructors
public Stack();
§3.8.1
//
public
public
public
public
public
Methods
boolean empty();
Object peek();
Object pop();
Object push(Object
int search(Object
§3.8.2
§3.8.3
§3.8.4
item); §3.8.5
o);
§3.8.6
}
Não usa interface: define operações da pilha como extensão de vector
- permite outras operações (de vector)
PFL
Cristina Ribeiro
Estruturas Lineares 2
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Aplicações
‰
Compilação de linguagens de programação
z verificação sintáctica (gramáticas)
• Pilha é adequada para guardar contextos, mantendo disponível o corrente
z chamada de procedimentos
• Chamada: empilha registo de activação
• Saída: desempilha registo correspondente
• visibilidade das variáveis decorre da sua posição na pilha
z avaliação de expressões
• Pilha mantém operandos, operadores e resultados intermédios
z expressões: conversão para notação posfixa
• Pilha mantém operadores até operandos respectivos estarem disponíveis
• Precedência e associatividade de operadores determina a ordem de saída
PFL
Stack - análise
‰
Operações sobre a pilha devem ser em tempo constante
z inserção e remoção na pilha só envolvem o topo
‰
Implementação em array
z em geral: tempo constante
z duplicação do array: gasta tempo da ordem da dimensão do array (para a cópia)
z amortização: duplicação é O(N) mas o custo é distribuído pelos acessos aos N
elementos adicionais obtidos; resultado é acréscimo constante em cada
operação
PFL
Cristina Ribeiro
Estruturas Lineares 3
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Fila
‰
Estrutura FIFO (first in, first out)
z Inserção na cauda e remoção da cabeça
‰
Operações
z Inserir:
enqueue
z Remover: dequeue
z Pesquisar: getFront
enqueue
dequeue
getFront
PFL
Interface
//
//
//
//
//
//
//
//
******************PUBLIC OPERATIONS*********************
void enqueue( x )
--> Insert x
Object getFront( )
--> Return least recently inserted item
Object dequeue( )
--> Return and remove least recent item
boolean isEmpty( )
--> Return true if empty; else false
void makeEmpty( )
--> Remove all items
******************ERRORS********************************
getFront or dequeue on empty queue
public interface Queue
{
boolean isEmpty( );
Object getFront( ) throws Underflow;
Object dequeue( ) throws Underflow;
void enqueue( Object X );
void makeEmpty( );
}
PFL
Cristina Ribeiro
Estruturas Lineares 4
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Lista Ligada
‰
Estrutura com nós que armazenam elementos
z manter referências para elementos do início e fim da lista
‰
Operações
z Inserir:
a seguir à posição corrente
z Remover: na posição corrente
z Pesquisar: por conteúdo ou por posição
first
last
PFL
Nós: inserção e remoção
Nó da lista
Class ListNode
{
Object element;
ListNode next;
}
Inserir a seguir ao
nó corrente
tmp = newListNode();
tmp.element = x;
tmp.next = current.next;
current.next = tmp;
ou
current.next = newListNode(x, current.next);
Apagar a seguir ao
nó corrente
current.next = current.next.next;
PFL
Cristina Ribeiro
Estruturas Lineares 5
LEIC-FEUP 2001/2002
Algoritmos e Estruturas de Dados 1
Operações na Lista
‰
Operações de acesso a elementos da lista
z requerem referência a nós da lista
z Necessário garantir que acesso aos nós da lista é seguro
‰
Acesso directo aos nós da lista
z não garante encapsulamento de informação
z utilizador da estrutura pode passar referência para objecto que não é da lista
‰
Lista definida em 2 partes: a lista e o iterador
z classe da lista: operações são só as permitidas sobre a lista como um todo
z classe do iterador: suporta operações de acesso a elementos
• mantém referência para uma lista e posição corrente
• possível mais do que um iterador sobre a mesma lista
PFL
Cristina Ribeiro
Estruturas Lineares 6