Escreva um programa C para criar uma pilha usando uma lista ligada (lista singularmente encadeada) - Desafio de Programação Resolvido em C

Informe o valor a ser empilhado: 8
O no 8 foi empilhado com sucesso.
Informe o valor a ser empilhado: 2
O no 2 foi empilhado com sucesso.
Informe o valor a ser empilhado: 5
O no 5 foi empilhado com sucesso.
Informe o valor a ser empilhado: 1
O no 1 foi empilhado com sucesso.
Informe o valor a ser empilhado: 4
O no 4 foi empilhado com sucesso.

O no desempilhado foi: 4
O no desempilhado foi: 1
O no desempilhado foi: 5
O no desempilhado foi: 2
O no desempilhado foi: 8

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

// Estrutura No (nó) usada para representar os elementos
// da pilha
struct No {
  int valor; // valor do nó
  struct No* proximo; // aponta para o próximo nó
};

// Estrutura Pilha para gerenciar a pilha
struct Pilha {
  struct No* topo; // aponta para o topo da pilha
};

// Função usada para criar e retornar um novo nó
// com o valor informado
struct No* criar_novo_no(int valor) {
  // reserva memória para o novo nó
  struct No* no = (struct No*) malloc(sizeof(struct No));
  // define o valor do nó
  no->valor = valor;
  // este novo nó não aponta para nenhum outro
  no->proximo = NULL;
  // e retornamos o nó recém-criado
  return no;
}

// função usada para criar uma nova pilha e inicializá-la
struct Pilha* criar_pilha() {
  // reservamos espaço para a estrutura Pilha
  struct Pilha* pilha = (struct Pilha*) malloc(sizeof(struct Pilha));
  // definimos que a pilha está vazia
  pilha->topo = NULL;
  // e retornamos a pilha recém-criada
  return pilha;
}

// função usada para verificar se a pilha está vazia
int vazia(struct Pilha* pilha) {
  // retorna 1 se a pilha estiver vazia e 0 em caso contrário
  return !pilha->topo;
}

// função usada para empilhar novos valores na pilha
void empilhar(struct Pilha* pilha, int valor) {
  // criamos um novo nó
  struct No* no = criar_novo_no(valor);
  // o próximo do novo nó aponta para o topo da pilha
  no->proximo = pilha->topo;
  // e o novo nó se torna o topo da pilha
  pilha->topo = no;
  // mostramos uma mensagem de sucesso
  printf("O no %d foi empilhado com sucesso.\n", valor);
}

// função para desempilhar e retornar um nó da pilha
int desempilhar(struct Pilha* pilha) {
  // apontamos para o nó no topo da pilha
  struct No* temp = pilha->topo;
  // obtemos o valor do nó removido
  int removido = temp->valor;
  // Movemos o ponteiro topo para o próximo nó
  pilha->topo = temp->proximo;
  // e liberamos a memória do nó removido
  free(temp);
  // e retornamos o nó removido
  return removido;
}

int main(int argc, char *argv[]) {
  int i, valor;
	
  // vamos criar uma nova pilha e empilhar 5 valores
  struct Pilha* pilha = criar_pilha();
  
  // vamos empilhar os 5 valores inteiros
  for (i = 0; i < 5; i++) {
    printf("Informe o valor a ser empilhado: ");
    scanf("%d", &valor);
    empilhar(pilha, valor);
  }
	 
  // agora vamos desempilhar os nós da pilha
  printf("\n");
  while (!vazia(pilha)) {
    printf("O no desempilhado foi: %d\n", desempilhar(pilha));
  } 
	 
  printf("\n\n");
  system("PAUSE");
  return 0;
}