/39

1/46


MCTA028-15: Programação Estruturada

Aula 10: Pilhas

Francisco de Assis Zampirolli e Wagner Tanaka Botelho

[email protected] / [email protected] / [email protected]
Universidade Federal do ABC (UFABC)
Centro de Matemática, Computação e Cognição (CMCC)
 2/46

Introdução
 3/46

Introdução
 Diferente das listas, os itens de uma pilha se encontram dispostos uns sobre os outros:
 Assim, pode-se inserir um novo item na pilha se o colocarmos ACIMA dos demais e
apenas removeremos o item que estiver no TOPO da pilha.

 Se quiser acessar determinado elemento da pilha, deve-se REMOVER todos os que

estiverem sobre ele:
 Portanto, as pilhas são conhecidas como estruturas do tipo ÚLTIMO a ENTRAR, PRIMEIRO
a SAIR ou Last In First Out (LIFO).
 4/46

Introdução
 Na Ciência da Computação: Pilha
 Uma pilha é uma estrutura de dados linear utilizada para 2
armazenar e organizar dados em um computador;
43
 Uma estrutura do tipo pilha é uma sequência de elementos do
MESMO TIPO. 20
 Vocês lembram da pilha de recursão controlada pelo Sistema 19
Operacional (SO)?
 5/46

Tipos de Pilhas
 6/46

Tipos de Pilhas
 Alocação estática com acesso sequencial:
 Espaço de memória é alocado no momento da compilação do programa, ou seja, é
necessário definir o número máximo de elementos da pilha.
 Alocação dinâmica com acesso encadeado:
 Espaço de memória é alocado em TEMPO DE EXECUÇÃO:
 A PILHA CRESCE à medida que NOVOS elementos são ARMAZENADOS;
 A PILHA DIMINUI à medida que elementos são REMOVIDOS.
 Cada elemento pode estar em uma área distinta da memória:
 Cada elemento da pilha deve armazenar, além da sua informação, o ENDEREÇO DE
MEMÓRIA onde se encontra o próximo elemento;
 Para acessar um elemento, é preciso PERCORRER todos os seus antecessores na
pilha.
 7/46

Pilha Sequencial Estática

 8/46

Pilha Sequencial Estática

 Tipo mais simples de pilha, definida utilizando um array e um CAMPO
ADICIONAL (qtd) que serve para indicar o quanto do array está ocupado
pelos elementos inseridos na pilha.
4 qtd

tamMax - 1

2
43
20
19 0
 9/46

Definindo o Tipo
 Ex_3.c 10/46

Definindo uma constante (tamanho do array).

Definindo o tipo pilha com dois campos:

+ qtd (int): indica quantidade de elementos
inseridos na pilha;
+ array num do tipo int: tipo de dado a ser
armazenado na pilha.
Redefinindo a struct para encurtar o
comando.
 11/46

Criando a Pilha
 12/46
Ponteiro para estrutura pilha.
Alocando a área de
memória para a pilha.
Armazena a quantidade de elementos inseridos
na lista.
Pilha *pi;

0 qtd

tamMax - 1

0
 13/46

“Destruindo” a Pilha
 14/46

Liberando a memória alocada para a estrutura que

representa a pilha.
Pilha *pi;

0 qtd

tamMax - 1

0
 15/46

Tamanho da Pilha
 2 qtd 16/46

tam = pi->qtd;
Indica o quanto do array já está ocupado pelos elementos tamMax - 1
inseridos na pilha.
Para saber o tamanho da pilha, basta retornar o valor de
qtd. 13
5 0

Se for verdade, algum problema aconteceu na

criação da pilha.

tam recebe o valor de qtd, ou seja, a

quantidade de elementos inseridos na pilha.
 17/46

Pilha Cheia
 18/46
Se ocorreu algum problema na criação da pilha, o
valor retornado será -1.
A variável qtd também é utilizada
para saber se a pilha está cheia.
Basta verificar se qtd = ao
tamanho do array (tamMax).
Se a pilha não estiver cheia, o valor retornado
será 0. tamMax qtd Pilha Cheia:
pi->qtd == tamMax
9 tamMax - 1
88
4
12
13
5 0
 19/46

Pilha Vazia
 20/46
Se ocorreu algum problema na criação da pilha, o
valor retornado será -1.
A variável qtd também é utilizada para
saber se a pilha está vazia. Basta verificar
se qtd = 0.
Se a pilha não estiver vazia, o valor retornado
será 0. 0 qtd Pilha Vazia:
pi->qtd == 0
tamMax - 1

0
 21/46

Inserindo na Pilha
 22/46
Se ocorreu algum problema na criação da pilha, o
valor retornado será 0.
Se a pilha estiver cheia, o valor
retornado será 0.

Inserindo o elemento (num) no

topo da pilha.
Incrementando a quantidade 234 qtd
de elementos da pilha.
insere_pilha(pPilha, 12); tamMax - 1
pi->num[2] = 12
pi->qtd = 3 77
12
insere_pilha(pPilha, 77); 13
pi->num[3] = 77 5 0
pi->qtd = 4
 23/46

Removendo um Elemento da Pilha

 24/46

Se ocorreu algum problema na criação da pilha ou

se estiver vazia, o valor retornado será 0.

Diminuindo em uma unidade a quantidade de

elementos armazenados na pilha.

43 qtd

remove_Pilha(pPilha);
tamMax - 1
pi->qtd = 3
O topo da pilha fica duplicado. 77
Entretanto, a posição é considerada 12
13
NÃO ocupada por elementos na
5 0
pilha.
 25/46

Pilha Dinâmica Encadeada

 26/46

Pilha Dinâmica Encadeada

 Pilha definida utilizando ALOCAÇÃO DINÂMICA e ACESSO ENCADEADO dos
elementos;
 Cada elemento da pilha é ALOCADO DINÂMICAMENTE:
 À medida que os elementos são inseridos no TOPO da pilha;
 Memória liberada, à medida que são removidos;
 É um ponteiro para uma estrutura que contém DOIS campos de
informação:
 DADO: utilizado par armazenar a informação inserida na pilha;
 PROX: ponteiro que indica o próximo elemento na pilha.
 27/46

Pilha Dinâmica Encadeada

 Além da estrutura que define seus elementos, a
Pilha *pi;
pilha utiliza ponteiro para ponteiro para guardar o Topo
primeiro elemento ou “TOPO” da pilha:
 Mesma ideia utilizada na implementação da
44
lista dinâmica encadeada;
 A diferença é que uma pilha apenas permite
76
um ÚNICO tipo de inserção e remoção:
 No TOPO da pilha.
2

NULL
 28/46

Definindo o Tipo
 pro
numero 29/46

x
Definindo o tipo que descreve cada elemento da
pilha.
+ *prox: ponteiro para o próximo elemento da pilha;
+ numero: tipo de dado (int) a ser armazenado na
pilha.

Redefinindo a struct para encurtar o comando.

Pilha É um ponteiro para Pilha que já é um ponteiro para a struct

*pi; elemento. Portanto, pi é um ponteiro para ponteiro. Por ser
ponteiro para ponteiro, pi armazena o endereço de um ponteiro.
Topo (*pi)

pro
numero

x
 30/46

Criando a Pilha
 Alocando uma área de memória 31/46
para armazenar o endereço do TOPO
da pilha.
*pi é um ponteiro para ponteiro
Se o conteúdo de pi é diferente de NULL, a
alocação da memória foi realizada.
Pilha *pi;

Topo

NULL
 32/46

“Destruindo” a Pilha
 33/46
Se a pilha foi criada com sucesso.
Cada elemento da pilha é percorrido,
enquanto conteúdo do TOPO da pilha
for diferente de NULL.
Pilha *pi;
Topo

no
44

76 no

2 no

NULL
 34/46

Tamanho da Pilha
 35/46

Tamanho da Pilha
 Diferente da pilha sequencial estática, para saber o
tamanho da pilha dinâmica, é preciso PERCORRER toda a
pilha, CONTANDO os elementos inseridos nela, até
encontrar o seu final (NULL).
 36/46
Verifica se a pilha foi criada com sucesso.

Nó aponta para o
primeiro elemento. Pilha *pi;
Percorre a pilha Topo cont = 3
21
0
até o valor do nó
for diferente de 44 no
NULL (fim da
pilha). 76 no

2 no
no
NULL
 37/46

Pilha Cheia
 38/46

Pilha Cheia
 Na pilha dinâmica encadeada somente será considerada CHEIA
quando NÃO tiver mais memória disponível para alocar novos
elementos:
 Apenas ocorrerá quando a chamada da função malloc()
retornar NULL.
 39/46

Pilha Vazia
 40/46

Pilha Vazia
 Uma pilha dinâmica encadeada é considerada VAZIA
sempre que o conteúdo do “TOPO” apontar para a
constante NULL.
 41/46
Verifica se a pilha foi criada com sucesso.

Acessa o conteúdo do topo (*pi) para comparar

com NULL. Topo Pilha *pi;
Se a pilha estiver vazia.

Topo Pilha *pi; NULL

Pilha não vazia.
44

76

NULL
 42/46

Inserindo um Elemento na Pilha

 43/46
Verifica se a pilha foi criada Pilha *pi; no
com sucesso. Topo 14
Alocando espaço na
memória. 76

Se não foi possível alocar 2

memória.
NULL
Copiando (para o nó) o número recebido
como parâmetro.
Nó está apontando para o topo (*pi) da pilha.
O topo (*pi) da pilha aponta para o nó.
 44/46

Removendo um Elemento da Pilha

 45/46

Topo Pilha *pi;

Verificar se a
no
remoção é possível. 44

76
Ponteiro no
aponta para o pi está apontando 2
topo da pilha (pi). para o próximo NULL
Liberando o nó. elemento da lista.
 46/46

Referências
 Slides do Prof. Luiz Rozante;

 SALES, André Barros de; AMVAME-NZE, Georges. Linguagem C: roteiro de

experimentos para aulas práticas. 2016;
 BACKES, André. Linguagem C Completa e Descomplicada. Editora Campus. 2013;

 SCHILDT, Herbert. C Completo e Total. Makron Books. 1996;

 DAMAS, Luís. Linguagem C. LTC Editora. 1999;

 DEITEL, Paul e DEITEL, Harvey. C Como Programar. Pearson. 2011;

 BACKES, André. Estrutura de Dados Descomplicada em Linguagem C. GEN LTC.

2016.