Estrutura

de Dados
Prof. Felipe Cavalaro
Pilha (Stack)
O que é uma pilha?
Pilha
É uma estrutura linear de dados que
pode ser acessada somente por uma de
suas extremidades para armazenar e
recuperar dados. É como uma pilha de
bandejas em uma lanchonete, que são
colocadas e retiradas do topo da pilha. A
última bandeja colocada é a primeira
removida da pilha. Por esta razão, uma
pilha é chamada de estrutura LIFO (do
inglês last in/first out) (DROZDEK, 2017).
Pilha

Pilha implementada com vetor

#define MAX 7
typedef struct p{ 6
n=2
int n; //quantidade de elementos 5
float vet[MAX]; 4
}pilhavet; 3
2
1 2 <- Topo (n-1)
0 5

Tem limite! Por isso é necessário fazer a função abaixo:

int cheia(pilhavet p); // verifica se a pilha está cheia
Pilha

Pilha implementada com lista encadeada

typedef struct n {
Pilha
float info;
struct n *prox; 2.3 5.7 1.4
}no; Topo info prox info prox info prox

typedef struct p{
no *topo;
}pilha; 2.3 <- Topo
5.7
1.4
Pilha
Exemplo de manipulação de dados na pilha
Pilha
Principais funções do TAD Pilha:

pilha* cria(); //cria uma nova pilha vazia

int vazia(pilha *p); //verifica se a pilha está vazia
void push(pilha *p, float dado); //empilha um elemento
float pop(pilha *p); //desempilha um elemento
void imprime(pilha *p); //mostra os dados da pilha
void libera(pilha *p); //libera o espaço em memória
Pilha

pilha* cria (){

pilha *p = (pilha*) malloc(sizeof(pilha));
p->topo = NULL;
return p;
}

int vazia (pilha *p){

return (p->topo==NULL);
}
Pilha
void push (pilha* p, float dado){
no *novo = (no*) malloc(sizeof(no));
novo->info = dado;
novo->prox = p->topo;
p->topo = novo;
}
Pilha
float pop (pilha* p){
if (vazia(p)) {
printf("Pilha vazia.\n");
exit(1); /* aborta programa */
}
float temp = p->topo->info;
no *aux = p->topo;
p->topo=aux->prox;
free(aux);
return temp;
}
Pilha
void imprime (pilha* p){
no *aux;
for (aux=p->topo; aux!=NULL; aux=aux->prox)
printf("%f\n",aux->info);
}
Pilha
void libera (pilha* p){
no *aux = p->topo;
while (aux!=NULL) {
no *temp = aux->prox;
free(aux);
aux = temp;
}
free(p);
}
Exercícios
1) Considere a existência de um tipo abstrato Pilha de números de ponto
flutuante, cuja interface está definida no arquivo pilha.h da seguinte forma:
typedef struct p pilha;
pilha* cria();
void push (pilha *p, float dado);
float pop (pilha *p);
int vazia (pilha *p);
void libera (pilha *p);
Sem conhecer a representação interna desse tipo abstrato Pilha e usando
apenas as funções declaradas no arquivo pilha.h, implemente uma função
que receba duas pilhas, p1 e p2, e passe todos os elementos da pilha p2
para o topo da pilha p1.
 Exercícios
1) Note que ao final dessa função, a pilha p2
vai estar vazia e a pilha p1 conterá todos os
elementos das duas pilhas. Essa função
deve obedecer o protótipo:
void concatena_pilhas (pilha *p1, pilha *p2);
Exercícios
2) Considere a existência de um tipo abstrato Pilha de números inteiros,
cuja interface está definida no arquivo pilha.h da seguinte forma:
typedef struct p pilha;
pilha* cria();
void push (pilha *p, int v);
int pop (pilha *p);
int vazia (pilha *p);
void libera (pilha *p);
Sem conhecer a representação interna desse tipo abstrato Pilha e usando
apenas as funções declaradas no arquivo pilha.h, implemente uma
função que receba uma pilha e retire todos os elementos impares dessa
pilha.
Essa função deve obedecer o protótipo: void retira_impares(pilha *p);
Exercícios
3) Considera o tipo abstrato Pilha de números inteiros do exercício
anterior (exercício 2) e escreva uma função que informa a quantidade de
negativos em uma pilha.
Use o protótipo: int contanegativos(pilha *p)
Obs.: Após na execução da função, a pilha deverá conter os mesmos
elementos e ordem que havia antes da execução da função.
Obrigado
felipe.cavalaro@fatec.sp.gov.br