(1) Faça um programa que armazena um conjunto de valores inteiros em uma pilha (stack). O valor -1 indica o final da leitura. Também deve ser lido um valor K a ser removido da pilha.
Faça uma função remove que recebe como parâmetro a pilha e o valor K a ser removido. Usando apenas as funções pop e push, remova o valor K da pilha (utilize uma estrutura auxiliar). A função deve retornar true, se o valor K for removido, false, caso contrário. O programa também deve ter uma função imprimir, que imprime os elementos da pilha, indicando quem é o topo. Faça a chamada da função na main e imprima a mensagem conforme o exemplo a seguir.
Exemplo de entrada:
Digite os elementos da pilha (-1 para encerrar):
2
7
10
8
4
-1
Digite o valor a ser removido: 8
Exemplo de saída:
O valor 8 foi removido com sucesso.
Elementos da pilha:
Topo: 4
41072
Faça uma função remove que recebe como parâmetro a pilha e o valor K a ser removido. Usando apenas as funções pop e push, remova o valor K da pilha (utilize uma estrutura auxiliar). A função deve retornar true, se o valor K for removido, false, caso contrário. O programa também deve ter uma função imprimir, que imprime os elementos da pilha, indicando quem é o topo. Faça a chamada da função na main e imprima a mensagem conforme o exemplo a seguir.
2
7
10
8
4
-1
Digite o valor a ser removido: 8
Elementos da pilha:
Topo: 4
41072
Passo 1
Beleza, o exercício pede um programinha em C que manipula uma pilha de inteiros. A gente vai ler vários inteiros até aparecer o -1 (que significa “pare de ler”), depois lê um valor K e chama uma função remove(pilha, K) que deve tirar só o K da pilha usando só
Conteúdo da matéria: pilha (stack), operações básicas
push
e pop
(e uma pilha auxiliar). Essa função devolve true
se encontrou e removeu o K, ou false
se não. Ainda tem que ter uma função imprimir
que mostre os elementos da pilha do topo até a base.Conteúdo da matéria: pilha (stack), operações básicas
push
e pop
, e uso de uma estrutura auxiliar.Passo 2
Vamos montar a pilha e as operações básicas. A ideia é usar um vetor
int dados[MAX]
e um índice topo
(inicialmente -1).- push(x): faz
dados[++topo] = x;
- pop(): retorna
dados[topo--];
(supondo que a pilha não esteja vazia)
Passo 3
Função remove(pilha, K):
- Cria uma pilha auxiliar vazia.
- Inicializa uma flag
achou = false
. - Enquanto a pilha principal não estiver vazia:
a)x = pop(pilha_principal)
b) Sex == K
e ainda não achou, defineachou = true
e não empurra pra auxiliar.
c) Senão, fazpush(auxiliar, x)
. - Agora a pilha principal está vazia; a pilha auxiliar tem tudo (menos o K se achou).
- Para restaurar a ordem original, tira tudo da auxiliar e empurra de volta na principal (isso inverte duas vezes, voltando à ordem original, excluindo o K).
- Retorna
achou
.
Passo 4
Função imprimir(pilha):
- Se a pilha estiver vazia, imprime “Pilha vazia”.
- Senão, imprime “Topo: ” e percorre o vetor de
topo
até 0, mostrando cada elemento (sem removê-los).
Passo 5
Na
main
:- Lê os inteiros até -1, chamando
push
para cada um. - Lê o valor K.
- Chama
remove(pilha, K)
. Se retornar true, imprime
“O valor K foi removido com sucesso.”
senão imprime
“O valor K não foi encontrado na pilha.” - Chama
imprimir(pilha)
.
Resposta
#include <stdio.h>
#include <stdbool.h>
#define MAX 100
typedef struct {
int dados[MAX];
int topo;
} Pilha;
void inicia(Pilha *p) {
p->topo = -1;
}
bool vazia(Pilha *p) {
return p->topo == -1;
}
bool push(Pilha *p, int x) {
if (p->topo == MAX - 1) return false; // overflow
p->dados[++(p->topo)] = x;
return true;
}
int pop(Pilha *p) {
if (vazia(p)) return -1; // underflow ou valor inválido
return p->dados[(p->topo)--];
}
bool removeValor(Pilha *p, int K) {
Pilha aux;
inicia(&aux);
bool achou = false;
// Desempilha tudo e filtra o K
while (!vazia(p)) {
int x = pop(p);
if (x == K && !achou) {
achou = true;
// não empurra para a auxiliar, ou seja, remove
} else {
push(&aux, x);
}
}
// Volta com o resto para a pilha original
while (!vazia(&aux)) {
push(p, pop(&aux));
}
return achou;
}
void imprimir(Pilha *p) {
if (vazia(p)) {
printf("Pilha vazia.\n");
return;
}
printf("Elementos da pilha:\n");
printf("Topo: %d\n", p->dados[p->topo]);
for (int i = p->topo; i >= 0; i--) {
printf("%d", p->dados[i]);
}
printf("\n");
}
int main() {
Pilha pilha;
inicia(&pilha);
printf("Digite os elementos da pilha (-1 para encerrar):\n");
while (1) {
int v;
scanf("%d", &v);
if (v == -1) break;
push(&pilha, v);
}
printf("Digite o valor a ser removido: ");
int K;
scanf("%d", &K);
if (removeValor(&pilha, K)) {
printf("O valor %d foi removido com sucesso.\n", K);
} else {
printf("O valor %d não foi encontrado na pilha.\n", K);
}
imprimir(&pilha);
return 0;
}