OBI - alguém participou? (além de mim?)

{IMPLEMENTACAO DE PILHA COM ALOCACAO DINAMICA DE MEMORIA}

Unit UPilha;

interface

type
    tipoPilha = integer;
    pPilha = ^no;
    no = record
          elemento :tipoPilha;
          proximo  :pPilha;
    end;

procedure inicializar (var top :pPilha);
function pilhaCheia :boolean;
function empilhar (var top :pPilha; num :tipoPilha) :boolean;
function pilhaVazia (top :pPilha) :boolean;
function desempilhar (var top :pPilha; var num :tipoPilha) :boolean;
function mostrarTopo (top :pPilha; var num :tipoPilha) :boolean;

implementation

{DECLARA INICIALMENTE O PONTEIRO TOPO COMO NULO E ALOCA UM ESPACO P/ AUX}
procedure inicializar (var top :pPilha);

begin
     top := NIL;
end;

{VERIFICA SE E POSSIVEL EMPILHAR UM ELEMENTO}
function pilhaCheia :boolean;

begin
     pilhaCheia := MAXAVAIL >= SIZEOF (no);
end;


{EMPILHA UM NUMERO ESPECIFICADO PELO USUARIO}
function empilhar (var top :pPilha; num :tipoPilha) :boolean;

var
   pil :pPilha;

begin
     if pilhaCheia then
        begin
             new (pil);
             pil^.proximo := top;
             pil^.elemento := num;
             top := pil;
             empilhar := true;
        end
     else
             empilhar := false;
end;

{VERIFICA SE A PILHA ESTA VAZIA}
function pilhaVazia (top :pPilha) :boolean;

begin
     pilhaVAzia := top <> NIL;
end;

{DESEMPILHA O ELEMENTO NO TOPO}
function desempilhar (var top :pPilha; var num :tipoPilha) :boolean;

var
   aux :pPilha;

begin
     if pilhaVazia (top) then
       begin
            num := top^.elemento;
            aux := top;
            top := aux^.proximo;
            dispose (aux);
            desempilhar := true;
       end
     else
            desempilhar := false;
end;

{MOSTRA O ELEMENTO NO TOPO}
function mostrarTopo (top :pPilha; var num :tipoPilha) :boolean;

begin
     if pilhaVazia (top) then
       begin
            num := top^.elemento;
            mostrarTopo := true;
       end
     else
            mostrarTopo := false;
end;

end.

//LISTA COM ALOCACAO DINAMICA DE MEMORIA (PADRAO ANSI), SENDO IMPLEMENTADO O
//CONCEITO DE PILHA.
//IMPLEMENTACAO FEITA POR FABIO VENDRAMIN GUIMARAES.
//ENGENHARIA DA COMPUTACAO, 24/03/2001 - 00:42 hs.
//PROFESSOR: EDUARDO COTRIN, MATERIA: LTPII.
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>

//TIPO DO ELEMENTO DA PILHA
typedef int T_elemento;

//ESTRUTURA DO NO: LISTA SIMPLESMENTE ENCADEADA
struct No {
	T_elemento info;
	struct No  *proximo;
	  };

typedef struct No Ponteiro_No;

//OBJETO PILHA
typedef struct {
      Ponteiro_No *topo;
      int         qtde;
	       } Pilha;

//PROTOTIPOS DOS METODOS DO OBJETO PILHA
void INICIALIZA_PILHA (Pilha *p);
int PILHA_VAZIA (Ponteiro_No top);
Ponteiro_No* PILHA_CHEIA (void);
int EMPILHAR (Pilha *p, T_elemento elemento);
int DESEMPILHAR (Pilha *p, T_elemento *elemento);
int QTDE_ELEMENTOS_PILHA (Pilha *p);
int ELEMENTO_TOPO (Pilha *p, T_elemento *elemento);
int PESQUISA (Pilha *p, T_elemento chave);

//BLOCO DE COMANDO PRINCIPAL
void main (void)

{  Pilha      pil;
   T_elemento num;
   char       opcao;

   INICIALIZA_PILHA (&pil);
   do {
	clrscr();
	puts ("Menu de Op?Æo da Pilha");
	puts ("1 - Inserir");
	puts ("2 - Remover");
	puts ("3 - Elemento do Topo");
	puts ("4 - Quantidade de Elementos");
	puts ("5 - Pesquisar elemento");
	puts ("6 - Sair");
	opcao = getche();
	switch (opcao)  {
	    case '1' : {
			  puts ("Digite o elemento: ");
			  scanf ("%i", &num);
			  if (EMPILHAR (&pil, num))
			     puts ("Elemento empilhado com sucesso");
			   else
			     puts ("Nao ha memoria dispon¡vel");
			  getche();
			  break;
		       }

	    case '2' : {
			  if (DESEMPILHAR (&pil, &num))
			     printf ("Numero desempilhado: %i", num);
			   else
			     puts ("Pilha vazia");
			  getche();
			  break;
		       }

	    case '3' : {
			  if (ELEMENTO_TOPO (&pil, &num))
			     printf ("Elemento no topo: %i", num);
			   else
			     puts ("Pilha vazia");
			  getche();
			  break;
		       }

	    case '4' : {
			  printf ("Quantidade de Elementos na pilha: %i", QTDE_ELEMENTOS_PILHA (&pil));
			  getche();
			  break;
		       }

	    case '5' : {
			  puts ("Digite o elemento: ");
			  scanf ("%i", &num);
			  if (PESQUISA (&pil, num))
			     puts ("Elemento existente na pilha");
			   else
			     puts ("Elemento nao existe na pilha");
			  getche();
			  break;
		       }

			}
      }
   while (opcao != '6');
}

//BLOCO DOS METODOS
//****************************************************************************
//INICIALIZA: A PILHA VAZIA E QUANTIDADE NULA
void INICIALIZA_PILHA (Pilha *p)

{
     p -> topo = NULL;
     p -> qtde = 0;
}
//****************************************************************************
/*VERIFICA SE A PILHA ESTA VAZIA, RETORNANDO 0 CASO ESTEJA VAZIA E 1 SE TIVER
  ELEMENTOS*/
int PILHA_VAZIA (Ponteiro_No *top)

{
    return top != NULL;
}
//****************************************************************************
/*VERIFICA SE A ESPACO PARA ALOCACAO, RETORNANDO NULL CASO NAO HAJA E RETORNAN-
  DO O ENDERECO INICIAL CASO HAJA ESPACO*/
Ponteiro_No *PILHA_CHEIA (void)

{
    return (Ponteiro_No*) malloc (sizeof (Ponteiro_No));
}
//****************************************************************************
/*EMPILHA UM ELEMENTO, E RETORNA 1 SE FOI POSSIVEL A INSERCAO E 0 CASO CONTRA-
  RIO*/
int EMPILHAR (Pilha *p, T_elemento elemento)

{
    Ponteiro_No *novo;

    if ((novo = PILHA_CHEIA ()) != NULL)
       {
	 novo -> proximo = p -> topo;
	 novo -> info = elemento;
	 p -> topo = novo;
	 ++ p -> qtde;
	 return 1;
       }
     else
	 return 0;
}
//****************************************************************************
/*RETIRA O ELEMENTO QUE ESTIVER NO TOPO E RETORNA 1 CASO FOR RETIRADO COM SU-
  CESSO E 0 CASO CONTRARIO*/
int DESEMPILHAR (Pilha *p, T_elemento *elemento)

{
    Ponteiro_No *remover;

    if (PILHA_VAZIA (p -> topo))
       {
	 *elemento = p -> topo -> info;
	 remover = p -> topo;
	 p -> topo = p -> topo -> proximo;
	 free (remover);
	 -- p -> qtde;
	 return 1;
       }
      else
	 return 0;
}
//****************************************************************************
//RETORNA A QUANTIDADE DE ELEMENTOS NA PILHA
int QTDE_ELEMENTOS_PILHA (Pilha *p)

{
    return p -> qtde;
}
//****************************************************************************
/*RETORNA POR REFERENCIA O ELEMENTO QUE ESTIVER NO TOPO, RETORNANDO NA FUNCAO
  1 CASO A PILHA TENHA ELEMENTOS E CASO CONTRARIO RETORNA 0, PILHA VAZIA*/
int ELEMENTO_TOPO (Pilha *p, T_elemento *elemento)

{
    return PILHA_VAZIA (p -> topo) ? *elemento = p -> topo -> info, 1 : 0;
}

/*PESQUISA UM ELEMENTO NA PILHA, RETORNANDO 1 SE EXISTIR O ELEMENTO E 0 CASO
  CONTRARIO*/
int PESQUISA (Pilha *p, T_elemento chave)

{
    Ponteiro_No *aux;

    for (aux = p -> topo; (aux != NULL) && (aux -> info != chave); aux = aux -> proximo);
    return (aux != NULL) && (aux -> info == chave) ? 1 : 0;
}