(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

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ó 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):
  1. Cria uma pilha auxiliar vazia.
  2. Inicializa uma flag achou = false.
  3. Enquanto a pilha principal não estiver vazia:
    a) x = pop(pilha_principal)
    b) Se x == K e ainda não achou, define achou = true e não empurra pra auxiliar.
    c) Senão, faz push(auxiliar, x).
  4. Agora a pilha principal está vazia; a pilha auxiliar tem tudo (menos o K se achou).
  5. 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).
  6. Retorna achou.

Passo 4

Função imprimir(pilha):
  1. Se a pilha estiver vazia, imprime “Pilha vazia”.
  2. Senão, imprime “Topo: ” e percorre o vetor de topo até 0, mostrando cada elemento (sem removê-los).

Passo 5

Na main:
  1. Lê os inteiros até -1, chamando push para cada um.
  2. Lê o valor K.
  3. 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.”
  4. 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;
}

Exercícios relacionados