I.

INTRODUO
Esta dica tem por objetivo a compreenso das pilhas. A escolha de implementao em funo de eventuais necessidades sua. Para explicar o algoritmo, eu usarei uma lista simplesmente ligada (ou encadeada). Assim sendo, a compreenso das listas encadeadas necessria.

II. Definio
A pilha uma estrutura de dados que armazena os dados na ordem LIFO (Last In First Out) em portugus ltimo a Entrar Primeiro a Sair). A recuperao de dados ser feita na ordem inversa de sua insero. Para implementar, escolhi uma lista ligada simplesmente, apresentada na vertical. A insero sempre feita no incio da lista, o primeiro elemento da lista ser o ltimo digitado; assim, a sua posio fica no topo da pilha. Eu no usei um ponteiro fino, como eu fiz no caso das listas simplesmente ligadas, j que o objetivo no abordar uma lista ligada, mas a pilha. O que nos interessa que o ltimo elemento inserido, seja o primeiro recuperado.

==III. A construo do prottipo de um elemento da pilha= Para definir um elemento da pilha ser usado o tipo struct. O elemento da pilha conter um campo dado e um ponteiro "seguinte". O ponteiro "seguinte" deve ser do mesmo tipo que o elemento, caso contrrio ele no poder apontar para o elemento. O ponteiro "seguinte" permitir o acesso para o prximo elemento. typedef struct ElementoLista {

char *dado; struct ElementoLista *seguinte; }Elemento; Para permitir as operaes na pilha, vamos salvar alguns elementos: o primeiro elemento o nmero de elementos

O primeiro elemento, que se encontra no topo da pilha, nos ajudar a realizar a operao de recuperao dos dados situados no topo da pilha. Para faz-lo, outra estrutura diferente ser utilizada (isso no obrigatrio, variveis podem ser utilizadas). Veja a composio: typedef struct ListaDetectada{ Elemento *incio; int tamanho; } Pilha; O ponteiro de incio contm o endereo do primeiro elemento da lista. Observao: Ns no vamos usar um ponteiro fino desta vez (veja as listas simplesmente encadeadas), pois no precisamos, j que s trabalharemos com o incio da lista. Seja qual for a posio na lista, o ponteiro de incio sempre aponta para o primeiro elemento, que estar no topo da pilha. O campo tamanho conter o nmero de elementos da pilha, independentemente da operao efetuada na pilha.

IV. Operaes nas pilhas

A. Inicializao
Prottipo da funo: void inicializao (Pilha *monte);

Esta operao deve ser feito antes de qualquer outra operao da pilha. Ela inicializa o ponteiro do incio com o ponteiro NULL incio, e o tamanho com o valor 0. A funo void inicializao (Pilha *monte){ monte->incio = NULL; monte->tamanho = 0; }

B. Insero de um elemento na pilha

Veja o algoritmo de insero e de backup dos componentes: Declarao de elementos a serem inseridos Alocao da memria para o novo elemento Preencher o contedo do campo de dados Atualizar o ponteiro do incio para o primeiro elemento (o topo da pilha) Atualizar o tamanho da pilha

Prottipo da funo: int empilhar (Pilha *monte, char *ado); A primeira imagem mostra o incio da insero, portanto, a lista tem o tamanho 1 depois da insero. A caracterstica da pilha no est bem realada com um nico elemento, j que o nico a ser recuperado.

Por outro lado, na segunda imagem podemos observar o comportamento da pilha. O que no devemos esquecer que a integrao sempre feita no topo da pilha (no incio da lista).

A funo /* empilhar (adicionar) um elemento da pilha */ int empilhar (Pilha * monte, char *dado){ Elemento *novo_elemento; if ((novo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL) return -1; if ((novo_elemento->dado = (char *) malloc (50 * sizeof (char))) == NULL) return -1; strcpy (novo_elemento->dado, dado); novo_elemento->prximo = monte->incio; monte-> incio = novo_elemento; monte->tamanho++; }

C. Tirar um elemento da pilha

Para excluir (remover ou desempilhar) o elemento da pilha, basta excluir o elemento para o qual aponta o ponteiro de incio. Esta operao no permite recuperar o dado no topo da pilha, mas apenas remov-lo. Prottipo da funo: int desempilhar (Pilha *monte); A funo retorna -1 em caso de falha, caso contrrio, ela retorna 0. Passos : O ponteiro remov_elem conter o endereo do primeiro elemento O ponteiro de incio apontar para o segundo elemento (aps a remoo do primeiro elemento, o segundo passar para o topo da pilha) O tamanho da pilha ser decrementado de um elemento

A funo int desempilhar (Pilha * monte){ Elemento *remov_elemento; if (monte->tamanho == 0) return -1; remov_elemento = monte->incio; tas-> incio = tas->incio->prximo; free (remov_elemento->dado); free (remov_elemento); monte ->tamanho--; return 0;

D. Exibir a pilha
Para exibir a pilha inteira, preciso se posicionar no incio da pilha (voc poder fazer isso com o ponteiro de incio). Em seguida, usando o ponteiro "seguinte" de cada elemento, a pilha ser atravessada do primeiro at o ltimo elemento. A condio de parada dada pelo tamanho da pilha. A funo /* exibio da pilha */ void exibe (Pilha * monte){ Elemento *corrente; int i; em curso= monte->incio; for(i=0;i<tas->tamanho;++i){ printf("\t\t%s\n", corrente->dado); em curso = em curso->prximo; } }

E. Recuperao do dado no topo da pilha

Para recuperar o dado no topo da pilha sem remov-lo, eu usei um macro. O macro l os dados do topo da pilha usando o ponteiro do incio.

#define pilha_dado(monte)

monte->incio->dado

V. Exemplo completo
pilha.h
/*********************\ pilha.h *

\*********************/ typedef struct ElementoLista{ char *dado; struct ElementoLista *seguinte;

} Elemento; typedef struct ListaDetectada{ Elemento *incio; int tamanho; } Pile;

/* inicializao */ void inicializao (Pilha *monte); /* EMPILER*/ int empilhar (Pilha *monte, char *dado); /* DESEMPILHAR*/ int desempilhar (Pilha *monte); /* Exibio do elemento no topo da pilha (LastInFirstOut) */ #define pilha_dado(monte) /* Exibe a pilha */ void exibe (Pilha *monte); monte->incio->dado

pile_function.h
/***********************\ pile_function.h *

\***********************/ void inicializao (Pilha *monte){ tas->incio = NULL; tas->tamanho = 0; } /* empilhar (adicionar) um elemento na pilha */ int empilhar (Pilha * monte, char *dado){ Elemento *novo_elemento; if ((novo_elemento = (Elemento *) malloc (sizeof (Elemento))) == NULL) return -1; if ((novo_elemento-> dado = (char *) malloc (50 * sizeof (char))) == NULL) return -1;

strcpy (novo_elemento->dado, dado); novo_elemento->seguinte = monte->incio; monte-> incio = novo_elemento; monte->tamanho++; } /* desempilhar (excluir um elemento da pilhe */ int desempilhar (Pilha * monte){ Elemento *remov_elemento; if (tas->tamanho == 0) return -1; remov_elemento = monte->incio; monte-> incio = monte->incio->seguinte; free (remov_elemento->dado); free (remov_elemento); monte->tamanho--; return 0; } /* exibio da pilha */ void exibe (Pilha * monte){ Elemento *em curso; int i; em curso = monte->incio; for(i=0;i<monte->tamanho;++i){ printf("\t\t%s\n", em curso->dado); em curso = em curso->seguinte; } }