Este  é  um tipo de estrutura de dados básico para a compreensão de
vários  outros  que  também  utilizam  alocação dinâmica de memória. Em uma
lista  encadeada,  cada  nó possui, além dos dados, um apontador que aponta
para  o  próximo  nó  da  lista.  Existe um apontador denominado INICIO que
aponta  para  o  primeiro  nó.  O  último  nó  tem  no  apontador  um valor
predefinido como final, geralmente NULL.

	Estrutura TNo
	.	Dado
	.	Próximo: Apontador
	fim

	A grande vantagem dessa estrutura com relação aos métodos estáticos
é  a  economia de memória, já que só é alocado um espaço de memória se nele
realmente  forem  guardadas  informações.  Além  disso  com  esse método, a
quantidade  de  informação  é limitada apenas pela quantidade de memória do
computador.  Ao  passo  que,  utilizando  um método estático de alocação de
memória,  toda  a memória utilizada durante a execução do programa deve ser
alocada previamente.

	A  desvantagem dessa estrutura está na busca de registros guardados
na  lista.  O  único  método de busca que pode ser utilizado nela são os de
pesquisa serial e pesquisa sequencial (este último depende da forma com que
os  registros  foram  inseridos  na lista). Vou demonstrar um  algoritmo de
inserção de registros de forma ordenada.

	InserirNo (TNo: Inicio; Dado: X)
	.	TNo: No, Temp
	.
	.	No = RequisitaNo ()
	.
	.	(verifica se é o primeiro nó da lista)
	.	se Inicio = NULL então 
	.	.	Inicio = No
	.	senão
	.	.	(procura o último nó e coloca o novo nó depois dele)
	.	.	Temp = Inicio
	.	.	enquanto Temp.Proximo <> NULL faça Temp = Temp.Proximo
	.	.	Temp.Proximo = No
	.	fim
	.
	.	No.Dado = X
	fim

	O  funcionamento  dessa função é muito simples. Busca-se o final da
lista, ou  seja, o nó cujo valor do próximo é NULL. Depois coloca-se o novo
nó  no  fim  da lista. É tão simples que é difícil explicar. Pode-se também
implementar  essa  função  de modo a guardar os dados em ordem crescente ou
decrescente.  Em  caso  de  dados  literais,  pode-se  guardá-los  em ordem
alfabética.

	Vamos ver agora a rotina para exclusão de um nó:

	Boleano: ExcluirNo (TNo: Inicio; Dado: X)
	.	TNo: No, Antecessor
	.
	.	(procura o nó a ser excluído)
	.	No = Inicio
	.	enquanto (No.Dado <> Dado) E (No <> NULL) No = No.Proximo
	.
	.	se No <> NULL então
	.	.	Antecessor = Inicio
	.	.	enquanto (Antecessor.Proximo <> No) E (Antecessor <> NULL)
				então Antecessor = Antecessor.Proximo
	.	.	Antecessor.Proximo = No.Proximo
	.	.	DesalocaNo (No)
	.	.	retorna VERDADE
	.	senão
	.	.	retorna FALSO
	.	fim
	fim

	Nesta função, ao invés de procurarmos o fim da lista, procuramos um
nó  que  contenha  um  determinado  Dado.  Se esse nó não existir, a função
retorna  FALSO.  Se  ele existir, ele deve ser excluído, mas de uma maneira
que a lista não se "quebre". O nó que aponta para ele deve passar a apontar
para  o no que ele (o nó a ser excluído) aponta, ou seja: O SEU NÓ ANTERIOR
DEVE PASSAR A SER ANTERIRO DO SEU PRÓXIMO.

	Pode-se  implementar,  analogamente  à lista encadeada simples, uma
lista  duplamente  encadeada.  Nesse  tipo  de estrutura, além do apontador
"Proximo",  há  o apontador "Anterior". Isso é mostrado na figura abaixo. A
implementação  dessa estrutura é mais simples que a da anterior, embora sua
compreensão possa ser um pouco "indigesta".

	Para saber mais...

------> Exemplo de Lista Encadeada Simples em C

------> Listas Duplamente Encadeadas
------> Pesquisa em Tabelas