Unit unitlde;

Interface

{  Descricao dos tipos de dados }
Type
  TListaDE_Dado = Integer;
  Ptr_ListaDE_Nodo = ^ListaDE_Nodo;
  ListaDE_Nodo = Record
                   Dado: TListaDE_Dado;
                   Ant, Prox : Ptr_ListaDE_Nodo;
                 End;

Var
  LDE: Ptr_ListaDE_Nodo;

Procedure ListaDE_Inicializa (Var LDE: Ptr_ListaDE_Nodo);
Procedure ListaDE_Posiciona_Inicio (Var LDE: Ptr_ListaDE_Nodo);
Procedure ListaDE_Posiciona_Final (Var LDE: Ptr_ListaDE_Nodo);
Procedure ListaDE_Insere_Antes (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado);
Procedure ListaDE_Insere_Depois (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado);
Procedure ListaDE_Exibe (LDE: Ptr_ListaDE_Nodo);
Function ListaDE_Pesquisa_Dado (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;
Function ListaDE_Pesquisa_Prox (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;
Function ListaDE_Remove_Nodo (Var LDE: Ptr_ListaDE_Nodo; Var Dado: TListaDE_Dado): Boolean;
Function ListaDE_Remove_Dado (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;

Implementation

{***********************************************}
{
  Descricao das Rotinas
}

Procedure ListaDE_Inicializa (Var LDE: Ptr_ListaDE_Nodo);
{   LDE = Ponteiro para o inicio da Lista Duplamente Encadeada, inicializa com NIL  }
Begin
  LDE := NIL;
End;

Procedure ListaDE_Posiciona_Inicio (Var LDE: Ptr_ListaDE_Nodo);
{ Move o ponteiro para o inicio da lista }
Begin
  If LDE <> NIL
  Then While LDE^.ant <> NIL
       Do LDE := LDE^.ant;
End;

Procedure ListaDE_Posiciona_Final (Var LDE: Ptr_ListaDE_Nodo);
{ Move o ponteiro para o final da lista }
Begin
  If LDE <> NIL
  Then While LDE^.prox <> NIL
       Do LDE := LDE^.prox;
End;

Procedure ListaDE_Insere_Antes (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado);
{   Insere um dado "antes" do nodo correntemente apontado }
Var
  novo,aux: Ptr_ListaDE_Nodo;
Begin
  New (novo);
  novo^.Dado := Dado;

  If LDE = NIL
  Then Begin
         LDE := novo;
         novo^.ant := NIL;
         novo^.prox:= NIL;
       End
  Else Begin
         aux := LDE^.ant;
         LDE^.ant := novo;
         novo^.prox := LDE;
         novo^.ant  := aux;
         If aux <> NIL
         Then aux^.prox := novo;
       End;
  LDE := novo; { Opcional: LDE passa a apontar para o novo nodo }
End;

Procedure ListaDE_Insere_Depois (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado);
{   Insere um dado "depois" do nodo correntemente apontado }
Var
  novo,aux: Ptr_ListaDE_Nodo;
Begin
  New (novo);
  novo^.Dado := Dado;

  If LDE = NIL
  Then Begin
         LDE := novo;
         novo^.ant := NIL;
         novo^.prox:= NIL;
       End
  Else Begin
         aux := LDE^.prox;
         LDE^.prox := novo;
         novo^.ant := LDE;
         novo^.prox:= aux;
         If aux <> NIL
         Then aux^.ant := novo;
       End;
  LDE := novo; { Opcional: LDE passa a apontar para o novo nodo }
End;


Procedure ListaDE_Exibe (LDE: Ptr_ListaDE_Nodo);
{ Exibe na tela o conteudo da lista duplamente encadeada }
Var
  aux: Ptr_ListaDE_Nodo;
Begin
  aux := LDE;
  ListaDE_Posiciona_Inicio(aux);
  While aux <> NIL 
  Do Begin
       Writeln (aux^.Dado);
       aux := aux^.prox;
     End;
  Write ('Tecle <enter> para continuar...');
  Readln;             { Faz uma pausa... }
End;

Function ListaDE_Pesquisa_Dado (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;
{ Procura na lista pela primeira ocorrencia do dado e retorna se achou ou nao e o ponteiro }
Begin
  If LDE <> NIL
  Then Begin
         ListaDE_Posiciona_Inicio(LDE);
         While (LDE^.dado <> Dado) AND (LDE^.prox <> NIL)
         Do LDE := LDE^.prox;
         if LDE^.dado = Dado
         Then ListaDE_Pesquisa_Dado := True
         Else ListaDE_Pesquisa_Dado := False;
       End
  Else ListaDE_Pesquisa_Dado := False;
End;

Function ListaDE_Pesquisa_Prox (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;
{ Procura na lista pela proxima ocorrencia do dado a partir da posicao atual 
  e retorna se achou ou nao e o ponteiro }
Begin
  If (LDE <> NIL)
  Then Begin
         While (LDE^.dado <> Dado) AND (LDE^.prox <> NIL)
         Do LDE := LDE^.prox;
         If LDE^.dado = Dado
         Then ListaDE_Pesquisa_Prox := True
         Else ListaDE_Pesquisa_Prox := False;
       End
  Else ListaDE_Pesquisa_Prox := False;
End;

Function ListaDE_Remove_Nodo (Var LDE: Ptr_ListaDE_Nodo; Var Dado: TListaDE_Dado): Boolean;
{ Remove o nodo correntemente apontado, retornando seu conteudo e se teve sucesso }
Var
  ant,prox: Ptr_ListaDE_Nodo;
  aux: Ptr_ListaDE_Nodo;
Begin
  If LDE <> NIL
  Then Begin
         aux := LDE;
         dado:= LDE^.dado;
         ant := LDE^.ant;
         prox:= LDE^.prox;
         If ant <> NIL
         Then ant^.prox := prox;
         If prox <> NIL
         Then prox^.ant := ant;

         If ant <> NIL
         Then LDE := ant
         Else If prox <> NIL
              Then LDE := prox
              Else LDE := NIL;

         dispose(aux);

         ListaDE_Remove_Nodo:=True;
       End
  Else ListaDE_Remove_Nodo:=False;
End;

Function ListaDE_Remove_Dado (Var LDE: Ptr_ListaDE_Nodo; Dado: TListaDE_Dado): Boolean;
{ Procura pela primeira ocorrência do nodo a partir da posicao atual, e se
  encontrar remove, retornando seu conteudo e se teve sucesso }
Var
  dadoaux: TListaDE_Dado;
  achou:boolean;
Begin
    achou:=ListaDE_Pesquisa_Dado (LDE, Dado);
    If achou
    Then ListaDE_Remove_Dado:=ListaDE_Remove_Nodo(LDE,dadoaux)
    Else ListaDE_Remove_Dado:=False;
End;

{ Inicializacao da UNIT }
Begin
  ListaDE_Inicializa(LDE);
End.