Este é, frustantemente, o tipo de estrutura de dados  mais  simples
de todos. Frustantemente sim, dado a sua importância e utilidade. Graças às
pilhas, somos capazes de escrever analisadores de  expressões  matemáticas,
compiladores  e uma  infinidade de  aplicações.  Nem  mesmo  a  programação
estruturada  seria  a  mesma   sem   as   pilhas,  já  que   sem   elas  os
microprocessadores não seriam capazes de executar subrotinas. É um  tipo de
estrutura tão importante que todos os microprocessadores têm pelo menos  um
registrador específico para manusear pilhas.
        Pilhas são estruturas de armazenamento de dados do tipo FILO (first
in, last out), ou seja, o  primeiro  dado a  entrar é  último a  sair.  Ela
possui um apontador TOPO que indica qual é o  último  dado da  pilha.  Esse
apontador é incrementado ou decrementado conforme os dados são inseridos ou
retirados da pilha.

        A pilha pode ser definida como uma estrutura:

	definição	MAX = 100	(por exemplo)
	definição	MIN = 1

	Estrutura TPilha
	.	Inteiro: Topo
	.	Dado: Vetor [MIN..MAX]	(vetor de dados de tamanho MAX)
	fim

        Dado é um tipo abstrato que pode ser qualquer coisa. Nessa estrutura
é definido também um vetor que vai da posição MIN até MAX (MIN  foi definido
com o valor 1 e MAX, com 100). O Topo precisa ser inicializado no início  do
programa com o valor MIN -1, no caso, 0.

        As rotinas de  inclusão  e  retirada  de  registros  geralmente  são
chamadas respectivamente POP e PUSH:

	Boleano: Push (Dado: X; TPilha: Pilha)
	.	se Pilha.Topo = MAX então
	.	.	MostrarErro ("Stack Overflow / Pilha Cheia")
	.	.	retorna FALSO
	.	fim
	.	Pilha.Topo = Pilha.Topo +1
	.	Pilha.Vetor [Pilha.Topo] = X
	.	retorna VERDADEIRO
	fim

        Aqui apareceu um termo que você provavelmente já  viu  antes (e  não
deve ter gostado), é "Stack Overflow". Esse é o termo usado quando uma pilha
estoura. Note que antes de colocar o dado na  pilha, a  rotina  verifica  se
isso é possível. Uma coisa semelhante vai acontecer quando tirarmos um  dado
da pilha: "Stack Underflow", que é quando  tentamos  tirar um  dado  de  uma
pilha vazia:

	Dado: Pop (TPilha: Pilha)
	.	Dado: X
	.	se Topo < MIN então
	.	.	MostrarErro ("Stack Underflow / Pilha Vazia")
	.	.	retorna NULL
	.	fim
	.	X = Pilha.Vetor [Pilha.Topo]
	.	Pilha.Topo = Pilha.Topo -1
	.	retorna X
	fim

        Uma pilha também pode ser implementada através de alocação  dinâmica
de  memória, o que é muito mais eficaz. Desse modo, a pilha  tem um  tamanho
teoricamente  ilimitado (limitado  pela  capacidade  do computador,  o que é
coisa pra caramba!). Além disso, através desse método, não há desperdício de
memória, pois ela não precisa ser  alocada a  não ser que realmente  existam
dados a serem armazenados.
        Essa pilha é implementada de maneira muito parecida  com  uma  lista
encadeada simples, como ilustrado abaixo:

        Nesse caso, ocorrerá OVERFLOW quando o sistema não for mais capaz de
alocar memória e, UNDERFLOW quando for requisitada a retirada de um dado  da
pilha e TOPO for igual a NULL. A implementação disso fica para outra vez...

	Para saber mais...

------> Exemplo em Pascal
------> Listas Encadeadas