SanduicheUma implementação bem simples, de uma pilha em C.

Pilha é uma estrutura de dados básica da computação. Seu comportamento é bem simples:

  • O último que entrou é o primeiro que sai.

Nos chamamos isso de LIFO de Last In First Out.

Esse código pode ser usado livremente para qualquer fim. Os autores são eu (José M. Silveira Neto) e o Marco Diego de Aurélio Mesquita.

Eis:

Pilha.h

#include
#include

typedef struct elemento_{
   void *dados;
   struct elemento_ * proximo;
} Elemento;

typedef struct pilha_{
   Elemento * topo;
}Pilha;

Pilha * Pilha_nova();
int Pilha_vazia(Pilha *p);
void Pilha_empilha(Pilha *p, void * algo);
void * Pilha_desempilha(Pilha *p);
int Pilha_destroi(Pilha *p);

#endif

Pilha.c

#include "pilha.h"

/* Cria uma nova pilha */
Pilha * Pilha_nova(){
   Pilha *nova = (Pilha *) calloc(1, sizeof(Pilha));

   if (!nova){
      printf("Pilha_nova: nao foi possivel alocar espaco para uma nova pilha. ");
      exit(1);
   }

   /* Inicializa os dados */
   nova->topo;
   return nova;
}

/* Retorna 1 se a pilha eh vazia e 0 caso contrario */
int Pilha_vazia(Pilha *p){
   if(!p){
      printf("Pilha_vazia: parametro nulo");
      exit(1);
   }
   return p->topo == NULL;
}

/* Empilha um dado algo */
void Pilha_empilha(Pilha *p, void * algo){
   Elemento *elemento;
   if(!p){
      printf("Pilha_empilha: parametro nulo");
      exit(1);
   }

   /* Crio um novo elemento e coloco ele no topo da pilha */
   elemento = (Elemento *) calloc(1, sizeof(Elemento));
   elemento->dados = algo;
   elemento->proximo = p->topo;
   p->topo = elemento;
}

/* retorna o topo da pilha. Depois da funcao ser executada, o topo nao sera mais aquele */
void * Pilha_desempilha(Pilha *p){
   Elemento *novo_topo;
   void * dados;
   if(!p){
      printf("Pilha_desempilha: parametro nulo");
      exit(1);
   }

   /* Se a pilha eh vazia */
   if(p->topo==NULL)
      return p->topo;
   /* Se tem algo na pilha */
   novo_topo = p->topo->proximo;
   dados = p->topo->dados;
   free(p->topo);
   p->topo = novo_topo;
   return dados;
}

/* Destroi a pilha, e o seu conteudo */
int Pilha_destroi(Pilha *p){
   Elemento * e;
   if(!p){
      printf("Pilha_destroi: parametro nulo");
      exit(1);
   }
   e = NULL;
   while((e=Pilha_desempilha(p))!=NULL){
      free(e);
   }
   free(p);
}

Uso:
Um exemplo de uso, para empilhar strings.

#include
#include "pilha.h"

Pilha *p;

int main(){
   /* Cria um novo elemento*/
   p = Pilha_nova();

   /* Empilha duas coisas */
   Pilha_empilha(p, (void *)"mundo");
   Pilha_empilha(p, (void *)"ola");

   /* Desempilha duas coisas */
   printf("%s\n", Pilha_desempilha(p));
   printf("%s\n", Pilha_desempilha(p));

   /* Nao esqueca de destruir a pilha */
   Pilha_destroi(p);
}

Para compilar isso fazemos:

$ gcc -c pilha.c
$ gcc teste.c pilha.o -o teste

Esse programa vai retornar:

ola
mundo