C calcular o resto de um número dentro do struct usando pilha

[NceiifadoR]

Boa noite 



estou com problema dentro do algoritmo que organiza as informações de forma de pilha. Não estou conseguindo, validar se o numero é par ou impa.

eu sei fazer a validação so não estou conseguindo inserir na estrutura de pilha.
  
  
#include <stdio.h>
#include <stdlib.h>

struct N{
 int num;
 struct N *prox;
};
typedef struct N n;

int tam;

int menu(void);
void inicia(n *PILHA);
void opcao(n *PILHA, int op);
void exibe(n *PILHA);
void libera(n *PILHA);
void push(n *PILHA);
n *pop(n *PILHA);


int main(void)
{
 n *PILHA = (n *) malloc(sizeof(n));
 if(!PILHA){
  printf("Memoria cheia !\n");
  exit(1);
 }else{
 inicia(PILHA);
 int opt;

 do{
  opt=menu();
  opcao(PILHA,opt);
 }while(opt);

 free(PILHA);
 return 0;
 }
}

void inicia(n *PILHA)
{
 PILHA->prox = NULL;
 tam=0;
}

int menu(void)
{
 int opt;

 printf("Escolha a opcao\n");
 printf("0. Sair\n");
 printf("1. Zerar a Estrutura\n");
 printf("2. Exibir os Elemento \n");
 printf("3. Adicionar Elemento (PUSH)\n");
 printf("4. Remover Elementos(POP)\n");
 printf("Opcao: "); 
 scanf("%d", &opt);

 return opt;
}

void opcao(n *PILHA, int op)
{
 n *tmp;
 switch(op){
  case 0:
   libera(PILHA);
   break;

  case 1:
   libera(PILHA);
   inicia(PILHA);
   break;

  case 2:
   exibe(PILHA);
   break;

  case 3:
   push(PILHA);
   break;

  case 4:
   tmp= pop(PILHA);
   if(tmp != NULL)
   printf("Removido: %3d\n\n", tmp->num);
   break;

  default:
   printf("Comando Invalido Tente Outra Vez...\n\n");
 }
}

int vazia(n *PILHA)
{
 if(PILHA->prox == NULL)
  return 1;
 else
  return 0;
}

n *aloca()
{
 n *novo=(n *) malloc(sizeof(n));
 if(!novo){
  printf("Memoria Cheia !\n");
  exit(1);
  
  
 }else{
     
  printf("Novo elemento: "); 
  scanf("%d", &novo->num);
  
   return novo; 
  }      
  

 }

void exibe(n *PILHA)
{
 if(vazia(PILHA)){
  printf("PILHA Vazia!\n\n");
  return ;
 }

 n *tmp;
 tmp = PILHA->prox;
 printf("Pilha:");
 while( tmp != NULL){
  printf("%5d", tmp->num);
  tmp = tmp->prox;
 }
 printf("\n        ");
 int count;
 for(count=0 ; count < tam ; count++)
  printf("  ^  ");
 printf("\nOrdem:");
 for(count=0 ; count < tam ; count++)
  printf("%5d", count+1);


 printf("\n\n");
}

void libera(n *PILHA)
{
 if(!vazia(PILHA)){
  n *proxN,
     *atual;

  atual = PILHA->prox;
  while(atual != NULL){
   proxN = atual->prox;
   free(atual);
   atual = proxN;
  }
 }
}

void push(n *PILHA)
{
 n *novo=aloca();
 novo->prox = NULL;

 if(vazia(PILHA))
  PILHA->prox=novo;
 else{
  n *tmp = PILHA->prox;

  while(tmp->prox != NULL)
   tmp = tmp->prox;

  tmp->prox = novo;
 }
 tam++;
}


n *pop(n *PILHA)
{
 if(PILHA->prox == NULL){
  printf("Pilha Esta Vazia...\n\n");
  return NULL;
 }else{
  n *ultimo = PILHA->prox,
              *penultimo = PILHA;

  while(ultimo->prox != NULL){
   penultimo = ultimo;
   ultimo = ultimo->prox;
  }

  penultimo->prox = NULL;
  tam--;
  return ultimo;
 }
} 

 

[arfneto]

Não use estruturas globais

 

Entenda que uma estrutura dessas, seja uma lista ou uma pilha ou uma fila ou qualquer desses containers de coisas, é uma coleção dessas coisas. No seu caso um int:

 

struct N{
 int num;
 struct N *prox;
};
typedef struct N n;

 

E então crie uma estrutura dessas coisas, os tais nós.

 

Uma pilha é uma coleção de nós, e cada nó tem um dado. No seu caso um int.

 

A pilha NÃO é um nó, um nó não é uma pilha. Ao programar assim, como está fazendo, só vai  ter mais problemas e demorar muito mais para escrever e testar. E vai ter maior dificuldade em aproveitar isso para o exercício seguinte, e isso é um desastre.

 

Evite isso a todo custo: uma struct global com o nome de UMA letrinha e declarada junto com o tipo? Muito difícil de ler, mesmo logo depois de escrever

 

• Não use estruturas globais. De jeito nenhum. Nenhuma variável global.
• Não use void f() use funções que retornam algo. E passe argumentos.
• Um printf() de 6 linhas é muitas vezes melhor que 6 printf() de uma linha

 

Compare

 

 printf("Escolha a opcao\n");
 printf("0. Sair\n");
 printf("1. Zerar a Estrutura\n");
 printf("2. Exibir os Elemento \n");
 printf("3. Adicionar Elemento (PUSH)\n");
 printf("4. Remover Elementos(POP)\n");
 printf("Opcao: "); 

Ou

 printf("\
     Escolha a opcao\n\
 \n\
 0. Sair\n\
 1. Zerar a Estrutura\n\
 2. Exibir os Elementos\n\
 3. Adicionar Elemento (PUSH)\n\
 4. Remover Elementos(POP)\n\
 \n\
 Opcao:  "); 

 

?

 

E o segundo executa dezenas de vezes mais rápido...

 

• Teste sempre o retorno de scanf()... Que adianta seguir com o menu se não ler nada?
• Se tem uma função menu() qual o propósito de deixar retornar uma opção inválida para o programa? 
• Não escreva NUNCA um programa interativo antes dele estar pronto. Só vai te atrasar. Mostrar um menu não acrescenta nada. Escreva as funções. Teste. Antes.

void inicia(n *PILHA);
void opcao(n *PILHA, int op);
void exibe(n *PILHA);

 

não acha que estaria melhor com algo como

 

Pilha* inicia();
int exibe(Pilha* p);
int libera(Pilha* p);
int POP(Pilha* p);
int TOP(Pilha* p);
int PUSH(Pilha* p);

 

O comum no caso de pilhas?

 

Use nomes mais significativos para suas estruturas.

 

Para que opcao() se tudo que tem em main() é isso? executar as opções do menu?