AED Pilhas

Pilhas
Nesta aula veremos o ADT

pilha
Uma pilha é usada em
muitas situações tais como
avaliação de expressões
aritméticas, chamada e
retorno de procedimentos e
funções e busca exaustiva
Algoritmos e (backtracking)
Estruturas de Dados I
José Augusto Baranauskas augusto@usp.br
Departamento de Física e Matemática – FFCLRP-USP http://dfm.ffclrp.usp.br/~augusto
Organização
Definição do ADT Pilha

Especificação
Operações sobre o ADT Pilha, utilizando pré- e
pós-condições
Implementação
Estática (contígua)
Dinâmica (encadeada)
2
Definição
Uma pilha (stack) é
uma estrutura de
dados na qual todas
inserções e remoções
de dados são
efetuadas numa única
extremidade,
denominada topo
(top) da pilha
3
Exemplo
Por exemplo, pense
numa pilha de pratos
comumente
encontrada em
restaurantes do tipo
self-service
4
Exemplo
Por exemplo, pense
comumente
encontrada em
self-service
Os pratos são
colocados sempre no
topo da pilha pelos
empregados...
5
Exemplo
Por exemplo, pense
comumente
encontrada em
self-service
Os pratos são
colocados sempre no
topo da pilha pelos
empregados...
6
Exemplo
Por exemplo, pense
comumente
encontrada em
self-service
Os pratos são
colocados sempre no
topo da pilha pelos
empregados...
7
Exemplo
Por exemplo, pense
comumente
encontrada em
self-service
Os pratos são
colocados sempre no
topo da pilha pelos
empregados...
8
Exemplo
Por exemplo, pense
comumente
encontrada em
self-service
Os pratos são
colocados sempre no
topo da pilha pelos
empregados...
9
Exemplo
Por exemplo, pense numa
pilha de pratos
comumente encontrada
em restaurantes do tipo
self-service
Os pratos são colocados
sempre no topo da pilha
pelos empregados e são
retirados a partir do topo
pelos clientes
O prato localizado no
fundo da pilha foi o
primeiro a ser colocado na
pilha e é o último a ser
retirado
10
Operações Fundamentais
Quando um item é
adicionado numa
pilha, usa-se a
operação Push
(inserir)
11
Operações Fundamentais
Quando um item é
adicionado numa
pilha, usa-se a
operação Push
(inserir)
Quando um item é
retirado de uma pilha,
usa-se a operação
Pop (retirar)
12
LIFO
O último item inserido
(Push) na pilha é
sempre o primeiro a
ser retirado (Pop)
Esta propriedade é
denominada Last In,
First Out (último a
entrar, primeiro a sair)
ou LIFO
13
Exemplo
pilha vazia inicialmente
topo
14
Exemplo
inserir (push) caixa Q
topo Q
15
Exemplo
inserir (push) caixa A
topo A
Q
16
Exemplo
remover (pop) uma caixa
topo Q
17
Exemplo
Q
topo
18
Exemplo
inserir (push) caixa R
topo R
19
Exemplo
inserir (push) caixa D topo D
R
20
Exemplo
D
inserir (push) caixa D
remover (pop) uma caixa topo R
21
Exemplo
inserir (push) caixa D topo M
R
inserir (push) caixa M
22
Exemplo
inserir (push) caixa D topo M
R
inserir (push) caixa M
Estado final
da pilha
23
Exemplo: Invertendo uma Linha
Suponha que você precisa de um

procedimento que leia uma linha e escreva-
a de forma reversa (de trás para frente)
Isto pode ser feito simplesmente inserindo
(push) cada caracter numa pilha à medida
que ele é lido
Quando a linha estiver terminada, basta
retirar (pop) os caracteres da pilha e eles
virão em ordem reversa
24
Invertendo uma Linha
void ReverseRead()
// Dada uma linha fornecida pelo usuário, escreve-a em ordem reversa
{ Stack line;
char ch;
while (! cin.eof() && ! line.Full())

{ cin >> ch; // Inserir cada caracter da linha para a pilha
line.Push(ch);
}
cout << "\nEsta é a linha em ordem reversa:\n";
while (! line.Empty())
{ line.Pop(ch); // Retirar cada caracter da pilha e escrevê-lo
cout << ch;
}
cout << endl;
} // end ReverseRead
25
Information Hiding
Note que o procedimento ReverseRead foi
escrito antes de se considerar como realmente a
pilha foi implementada
Isto é um exemplo de ocultamento de
informação (information hiding)
Se alguém já escreveu os métodos para
manipulação de pilhas, então podemos usá-los
sem conhecer os detalhes de como as pilhas são
mantidas na memória ou como as operações em
pilhas são realmente efetuadas
26
Information Hiding
Information hiding facilita a mudança de
implementação: se uma implementação é mais
eficiente, então apenas as declarações e os
métodos de manipulação de pilhas serão
alterados
O programa torna-se mais legível: o
aparecimento das palavras Push e Pop alertam
quem está lendo sobre o que está ocorrendo
Separando o uso de estruturas de dados da sua
implementação ajuda a melhorar o projeto top-
down (do nível maior de abstração para o menor;
do menor detalhamento para o maior) tanto de
estruturas de dados quanto de programas
27
Especificação
Operações:
Criação
Destruição
Status
Operações Básicas
Outras Operações
28
Criação
Stack::Stack();
pré-condição: nenhuma
pós-condição: Pilha é criada e iniciada
como vazia
29
Destruição
Stack::~Stack();
pré-condição: Pilha já tenha sido criada
pós-condição: Pilha é destruída
30
Status
bool Stack::Empty();
pós-condição: função retorna true se a
pilha está vazia; false caso contrário
31
Status
bool Stack::Full();
pós-condição: função retorna true se a
pilha está cheia; false caso contrário
32
void Stack::Push(StackEntry x);

pré-condição: Pilha já tenha sido criada e
não está cheia
pós-condição: O item x é armazenado no
topo da pilha
O tipo StackEntry depende
da aplicação e pode variar
desde um simples caracter ou
número até uma struct ou
class com muitos campos
33
void Stack::Pop(StackEntry &x);

não está vazia
pós-condição: O item no topo da pilha é
removido e seu valor é retornado na
variável x
34
Outras Operações
void Stack::Clear();
pós-condição: todos os itens da pilha são
descartados e ela torna-se uma pilha vazia
35
Outras Operações
int Stack::Size();
pós-condição: a função retorna o número
de itens na pilha
36
Outras Operações
void Stack::Top(StackEntry &x);

não está vazia
pós-condição: A variável x recebe uma
cópia do item no topo da pilha; a pilha
permanece inalterada
37
Pontos Importantes
Uma analogia útil para uma pilha consiste

em pensar em uma pilha de pratos: os
pratos são colocados e retirados sempre a
partir do topo da pilha
As operações básicas são Push (insere um
elemento na pilha) e Pop (retira um
elemento da pilha)
38
Implementação Contígua
Veremos inicialmente os detalhes de

implementação de pilhas utilizando
vetores (arrays)
Este tipo de implementação é também
denominada estática e contígua (ou
seqüencial)
Logo a seguir, veremos a
implementação encadeada dinâmica
de pilhas
39
As entradas em uma pilha
serão armazenadas no início
10
de um vetor, como mostra
8
este exemplo
4
[1] [2] [3] [4] [5] [6] ...
4 8 10
Um vetor de inteiros
Nós não nos interessamos para o que
está armazenado nesta parte do vetor
40
As entradas possuem
ordem. A figura abaixo não
8
representa a mesma pilha
4
que a anterior...
10
[1] [2] [3] [4] [5] [6] ...
10 4 8
41
Assim...
10
8
≠ 8
4
4 10
42
Nós precisamos também armazenar o
topo da pilha
10
8
3 Um inteiro armazena
4
o topo da pilha
[1] [2] [3] [4] [5 ] [6] ...
4 8 10
43
Questão
Utilize estas idéias
para escrever uma
declaração de tipo que
poderia implementar o
tipo de dado pilha. A
declaração deve ser
um objeto com dois
campos de dados.
Faça uma pilha capaz
de armazenar 100 Você tem 3 minutos
inteiros para escrever a declaração
44
Uma Solução
const int MaxStack = 100;

class Stack
{ public:
Stack();
void Push(int x);
void Pop(int &x);
...
private:
int top; // topo da pilha
int Entry[MaxStack+1]; // vetor com elementos
};
45
Uma Solução
const int MaxStack = 100;

class Stack
{ public:
Stack(); Observe que o tipo
void Push(int x); StackEntry nesse caso é
void Pop(int &x); um inteiro
...
private:
int top; // topo da pilha
int Entry[MaxStack+1]; // vetor com elementos
};
46
Criação
Stack::Stack()
A pilha deve iniciar vazia. A convenção

é que top = 0
[1] [2] [3] ... Stack::Stack()
Entry {
top = 0;
top 0 }
47
Destruidor
Stack::~Stack()
Usando alocação estática para implementar a pilha (vetor), o destruidor
não será necessário. Em todo caso, colocaremos apenas uma mensagem que
o objeto foi destruído
[1] [2] [3] ... Stack::~Stack()
Entry {
cout << “Pilha destruída”;
top }
48
Status: Empty
bool Stack::Empty()
Lembre-se que a pilha inicia
vazia, com top = 0...
[1] [2] [3] ... bool Stack::Empty()

Entry {
return (top == 0);
top 0 }
49
Status: Full
bool Stack::Full()
...e que MaxStack é o número
máximo de elementos da pilha
[1] [2] [3] ... bool Stack::Full()

Entry 8 4 10 {
return (top == MaxStack);
top 3 }
50
Operações Básicas: Push
void Stack::Push(int x)
Nós fazemos uma chamada a
Push(17)
[1] [2] [3] ... Quais valores serão

armazenados em
Entry 8 4 Entry e top
depois que a chamada
de procedimento
top 2 termina?
51
Depois da chamada a Push(17),

nós teremos esta pilha:
[1] [2] [3] ... [1] [2] [3] ...
Entry 8 4 8 4 17
top 2 3
52
Antes de inserir, é conveniente
verificar se há espaço na pilha
{ if (Full())
[1] [2] [3] ... { cout << “Pilha Cheia”;
abort();
Entry 8 4 }
...
top 2
}
53
Se houver, basta inserir na
próxima posição livre do vetor
{ if (Full())
[1] [2] [3] ... { cout << “Pilha Cheia”;
abort();
Entry 8 4 17 }
top++;
top 3 Entry[top] = x;
}
54
Operações Básicas: Pop
void Stack::Pop(int &x)

Nós fazemos uma chamada a
Pop(x)
[1] [2] [3] ... Quais valores serão

armazenados em
Entry 8 4 17 Entry, top e x
depois que a chamada
de procedimento
top 3 termina?
55

Depois da chamada a Pop(x),
nós teremos esta pilha:
[1] [2] [3] ... [1] [2] [3] ...
Entry 8 4 17 8 4
top 3 2
x 17
56

Antes de remover, é conveniente
verificar se a pilha não está vazia
{ if (Empty())
[1] [2] [3] ... { cout << “Pilha Vazia”;
abort();
Entry 8 4 17 }
...
top 3
}
x
57

Se não estiver vazia, basta retirar
o elemento do topo do vetor
{ if (Empty())
[1] [2] [3] ... { cout << “Pilha Vazia”;
abort();
Entry 8 4 }
x = Entry[top] ;
top 2 top = top - 1;
}
x 17
58
Exercícios
Defina a operação Clear utilizando apenas as
operações Empty e Pop
Defina a operação Clear utilizando diretamente
com os campos do objeto (vetor e topo)
Defina a operação Top utilizando apenas Push e
Pop e Empty
Defina a operação Top utilizando diretamente
com os campos do objeto (vetor e topo)
Defina a operação Size
Quais as vantagens e desvantagens de cada
uma destas construções?
59
Solução Clear
Usando apenas Empty Utilizando campos do
e Pop objeto
void Stack::Clear() void Stack::Clear()

{ int x; {
top = 0;
while(! Empty()) }
Pop(x);
}
60
Solução Top
Usando apenas Push Utilizando campos do
e Pop objeto
void Stack::Top(int &x) void Stack::Top(int &x)

{ if(Empty()) { if(top == 0)
{ cout << “Pilha vazia”; { cout << “Pilha vazia”;
abort(); abort();
} }
Pop(x); x = Entry[top];
Push(x); }
}
61
Solução Size
int Stack::Size()
{
return top;
}
62
Pontos Importantes
Até este ponto vimos uma forma de
implementação de pilhas, usando vetores
A vantagem de usar vetores é a simplicidade dos
programas
Uma desvantagem deste tipo de implementação
é que o tamanho da pilha é definido a priori pelo
programador, desperdiçando espaço não
utilizado
Nos próximos slides, veremos uma
implementação diferente, que otimiza a
quantidade de memória utilizada
63
Implementação Dinâmica
As entradas são colocadas em uma
estrutura (StackNode) que contém
um campo com o valor existente na 10
pilha (Entry) e outro campo é um 8
apontador para o próximo elemento
4
na pilha (NextNode)
Nó
(StackNode)
10 8 4
Campo de dados Campo de ligação

(Entry) (NextNode)
64
Implementação Dinâmica
Nós precisamos também
armazenar o topo da pilha
10
8
4
Um ponteiro armazena
o topo da pilha Nó
(StackNode)
10 8 4
top
Campo de dados Campo de ligação
(Entry) (NextNode)
65
Questão
Utilize estas idéias

para escrever uma
declaração de tipo que
poderia implementar o
tipo de dado pilha
capaz de armazenar
inteiros. A declaração
deve ser um objeto
com dois campos de
dados Você tem 5 minutos
para escrever a declaração
66
Uma Solução
class Stack
{ public:
Stack();
void Push(int x);
void Pop(int &x);
...
private:
// declaração de tipos
struct StackNode
{ int Entry; // tipo de dado colocado na pilha
StackNode *NextNode; // ligação para próximo
// elemento na pilha
};
typedef StackNode *StackPointer;
// declaração de campos
StackPointer top; // Topo da pilha
};
67
Uma Solução
class Stack
{ public:
Stack();
void Push(int x); Observe que o tipo
void Pop(int &x);
...
StackEntry nesse caso é
private: um inteiro
// declaração de tipos
struct StackNode
{ int Entry; // tipo de dado colocado na pilha
StackNode *NextNode; // ligação para próximo
// elemento na pilha
};
typedef StackNode *StackPointer;
// declaração de campos
StackPointer top; // Topo da pilha
};
68
Criação
Stack::Stack()
A pilha deve iniciar vazia, ou seja,
top está “aterrado”
Stack::Stack()
top
{
top = NULL;
}
69
Destruição
Stack::~Stack()
Usando alocação dinâmica a pilha, o destruidor deve retirar todos os elementos da
pilha enquanto ela não estiver vazia. Lembre-se que atribuir NULL a top não
libera o espaço alocado anteriormente!
Stack::~Stack()
8 { int x;
top while ( ! Empty() )
Pop(x);
}
70
Status: Empty
bool Stack::Empty()
Lembre-se que a pilha inicia
vazia, com top = NULL...
bool Stack::Empty()
top
{
return (top == NULL);
}
71
Status: Full
bool Stack::Full()
...e que não há limite quanto ao número
máximo de elementos da pilha
bool Stack::Full()
{
10 8
top return false;
}
72
Considere agora uma pilha vazia, o que significa top = NULL e adicione o primeiro nó.
Assuma que esse nó já foi criado em algum lugar na memória e pode ser localizado usando
uma variável p do tipo ponteiro (StackPointer)
top top
Pilha Pilha de
Vazia tamanho 1
p 8 p 8
73
Assim, colocando (Push) p na pilha consiste nas instruções:
p->NextNode = top;
...
p
p
10
10
top top
8 8
Pilha de
tamanho 1
74
p->NextNode = top;
top = p;
p
p
10
10
top top
8 8
Pilha de Pilha de
tamanho 1 tamanho 2
75
p->NextNode = top;
top = p;
p
p
10
10
top top
8 8
Pilha de Pilha de
tamanho 1 tamanho 2
A ligação tracejada foi removida

As ligações em negrito foram adicionadas
76
Inicialmente, alocamos o novo nó, void Stack::Push(int x)

usando o ponteiro p { StackPointer p;
p p = new StackNode;
...
top
8
}
77
Inicialmente, alocamos o novo nó, void Stack::Push(int x)

usando o ponteiro p. Se não houver { StackPointer p;
espaço na memória, escrevemos uma
mensagem de erro e terminamos
if(p == NULL)
{ cout << “Memoria insuficiente”;
top abort();
}
8
...
}
78
Caso contrário, colocamos o elemento x no void Stack::Push(int x)

campo de dados de p { StackPointer p;
if(p == NULL)
10 { cout << “Memoria insuficiente”;
top abort();
}
8
p->Entry = x;
...
}
79

campo de dados de p e alteramos os { StackPointer p;
ponteiros
if(p == NULL)
10 { cout << “Memória insuficiente”;
top abort();
}
8
p->Entry = x;
p->NextNode = top;
...
}
80

campo de dados de p e alteramos os { StackPointer p;
ponteiros
if(p == NULL)
10 { cout << “Memoria insuficiente”;
top abort();
}
8
p->Entry = x;
p->NextNode = top;
top = p;
}
81
Para retirar um elemento da pilha...
top 10 8 4
82
top 10 8 4
...usamos um ponteiro auxiliar p
p
10 p = top;
top 8 4
83
top 10 8 4
p
10 p = top;
top 8 4
...alteramos top para o nó seguinte...
p
top 10 8 4 top = top->NextNode
84
top 10 8 4
p
10 p = top;
top 8 4
...alteramos top para o nó seguinte...
p
top 10 8 4 top = top->NextNode
...e, finalmente, liberamos o espaço apontado por p

p
top delete p;
8 4
85

Inicialmente, verificamos se a pilha está vazia. Em caso afirmativo, imprimimos uma
mensagem de erro e terminamos
{ StackPointer p;
top if (Empty())
Pilha
{ cout << “Pilha Vazia”;
Vazia abort();
}
...
86

Caso contrário, armazenamos o valor do topo na variável x

{ StackPointer p;
p
if (Empty())
8 4 abort();
top }
x = top->Entry;
...
x 8
}
87

Apontamos o ponteiro auxiliar p para o topo da pilha...

{ StackPointer p;
p
if (Empty())
8 4 abort();
top }
x = top->Entry;
p = top;
...
x 8
}
88

Apontamos o ponteiro auxiliar p para o topo da pilha; alteramos o topo para o próximo nó...

{ StackPointer p;
p
if (Empty())
8 4 abort();
top }
x = top->Entry;
p = top;
top = top->NextNode;
x 8 ...
}
89

Apontamos o ponteiro auxiliar p para o topo da pilha; alteramos o topo para o próximo nó e,
finalmente, liberamos o espaço apontado por p (antigo topo)
{ StackPointer p;
p
8 if (Empty())
4 abort();
top }
x = top->Entry;
p = top;
x 8 delete p;
}
90

Apontamos o ponteiro auxiliar p para o topo da pilha; alteramos o topo para o próximo nó e,
finalmente, liberamos o espaço apontado por p (antigo topo)
{ StackPointer p;
p
if (Empty())
4 abort();
top }
x = top->Entry;
p = top;
x 8 delete p;
}
91
Outras Operações: Exercícios
Defina a operação Clear utilizando apenas as
operações Empty e Pop
Defina a operação Clear utilizando diretamente
ponteiros
Defina a operação Top utilizando apenas Push e
Pop e Empty
Defina a operação Top utilizando diretamente
ponteiros
Defina a operação Size
Há alguma ineficiência em sua implementação? Em
caso afirmativo, estenda o objeto de forma a torná-la
mais eficiente
Quais as vantagens e desvantagens de cada
uma destas construções?
92
Solução Clear
Usando apenas Empty e Utilizando campos do
Pop objeto
void Stack::Clear() void Stack::Clear()

{ int x; { StackPointer p;
while(! Empty()) while(top != NULL)

Pop(x); { p = top;
} top = top->NextNode;
delete p;
}
}
93
Solução Top
Usando apenas Push Utilizando campos do
e Pop objeto
void Stack::Top(int &x) void Stack::Top(int &x)

{ if(Empty()) { if(top == NULL)
{ cout << “Pilha vazia”; { cout << “Pilha vazia”;
abort(); abort();
} }
Pop(x); x = top->Entry;
Push(x); }
}
94
Solução Size
int Stack::Size()
{ StackPointer p;
int s=0;
p = top;
while(p != NULL)
{ s++;
p = p->NextNode;
}
return s;
}
95
Pontos Importantes
Nesta última parte, vimos uma forma de
implementação de pilhas usando alocação
dinâmica
A vantagem de usar alocação dinâmica (quando
comparada com a implementação utilizando
vetores) é que não é necessário definir o
tamanho da pilha, evitando desperdício de
espaço
Uma desvantagem deste tipo de implementação
é que, a cada chamada de Push e Pop, memória
deve ser alocada/liberada, o que pode tornar
essa implementação, em geral, um pouco mais
lenta do que a pilha contígua
96

AED Pilhas

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

AED Pilhas

Transféré par

Droits d'auteur :

Formats disponibles

Pilhas

Nesta aula veremos o ADT

Definição do ADT Pilha

Suponha que você precisa de um

while (! cin.eof() && ! line.Full())

void Stack::Push(StackEntry x);

void Stack::Pop(StackEntry &x);

void Stack::Top(StackEntry &x);

Uma analogia útil para uma pilha consiste

Veremos inicialmente os detalhes de

[1] [2] [3] [4] [5] [6] ...

[1] [2] [3] [4] [5] [6] ...

[1] [2] [3] [4] [5 ] [6] ...

const int MaxStack = 100;

const int MaxStack = 100;

A pilha deve iniciar vazia. A convenção

[1] [2] [3] ... bool Stack::Empty()

[1] [2] [3] ... bool Stack::Full()

[1] [2] [3] ... Quais valores serão

Depois da chamada a Push(17),

[1] [2] [3] ... [1] [2] [3] ...

void Stack::Pop(int &x)

[1] [2] [3] ... Quais valores serão

void Stack::Pop(int &x)

[1] [2] [3] ... [1] [2] [3] ...

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Clear() void Stack::Clear()

void Stack::Top(int &x) void Stack::Top(int &x)

Campo de dados Campo de ligação

Utilize estas idéias

A ligação tracejada foi removida

Inicialmente, alocamos o novo nó, void Stack::Push(int x)

Inicialmente, alocamos o novo nó, void Stack::Push(int x)

Caso contrário, colocamos o elemento x no void Stack::Push(int x)

Caso contrário, colocamos o elemento x no void Stack::Push(int x)

Caso contrário, colocamos o elemento x no void Stack::Push(int x)

 ...e, finalmente, liberamos o espaço apontado por p

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Pop(int &x)

void Stack::Clear() void Stack::Clear()

while(! Empty()) while(top != NULL)

void Stack::Top(int &x) void Stack::Top(int &x)

Vous aimerez peut-être aussi

Nesta aula veremos o ADT

Definição do ADT Pilha

Suponha que você precisa de um

Uma analogia útil para uma pilha consiste

Veremos inicialmente os detalhes de

...e, finalmente, liberamos o espaço apontado por p