tpu/u_listpi.pas

{ ppc386 -va -vh *.pas }
{ COMIENZO DE DESCRIPCION

  Listas de enteros por punteros. keywords: lista, punteros

FIN DE DESCRIPCION }
{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
{ $Id: u_listpi.pas,v 1.1 2002/04/25 15:57:09 mstorti Exp mstorti $}

unit u_listpi;

interface

type

  tipo_elemento = integer;

  ptipo_celda = ^tipo_celda;
  tipo_celda = record
    elemento: tipo_elemento;
    sig     : ptipo_celda
  end;

  posicion = ptipo_celda;

  listpi = object
  private
    cab : posicion;
    procedure ERROR (s: string);
  public
    procedure INSERTA   (x: tipo_elemento; p: posicion);
    function  LOCALIZA  (x: tipo_elemento): posicion;
    function  RECUPERA  (p: posicion) : tipo_elemento;
    procedure SUPRIME   (p: posicion) ;
    function  SIGUIENTE (p: posicion) : posicion;
    function  ANTERIOR  (p: posicion) : posicion;
    function  ANULA   : posicion;
    function  PRIMERO : posicion;
    function  FIN     : posicion;
    procedure IMPRIME (s : string) ;
  end ;			    

  implementation

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
procedure listpi.ERROR (s: string);
begin
  write ('error: ');
  writeln (s);
  halt;
end; {ERROR}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
procedure listpi.INSERTA (x: tipo_elemento; p: posicion);
var
  temp : posicion;
begin
  temp := p^.sig;
  new (p^.sig);
  p^.sig^.elemento := x;
  p^.sig^.sig := temp;
end; {INSERTA}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.LOCALIZA (x: tipo_elemento): posicion;
var
  q: posicion;
begin
  q := PRIMERO;
  while (q^.sig <> nil) 
    and (q^.sig^.elemento <> x) do q := q^.sig;
  LOCALIZA := q;
end; {LOCALIZA}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.RECUPERA (p: posicion): tipo_elemento;
begin
  RECUPERA := p^.sig^.elemento;
end; {RECUPERA}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
procedure listpi.SUPRIME (p: posicion);
begin
  p^.sig := p^.sig^.sig;
end; {SUPRIME}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.SIGUIENTE (p: posicion): posicion;
begin
  SIGUIENTE := p^.sig;
end; {SIGUIENTE}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.ANTERIOR (p: posicion): posicion;
var
  q,r : posicion;
begin
  r := PRIMERO ;
  q := PRIMERO ;
  while (q <> p) and (q^.sig <> nil) do begin
    r := q;
    q := q^.sig;
  end;
  ANTERIOR := r;
end; {ANTERIOR}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.ANULA : posicion;
begin
  new (cab);
  cab^.sig := nil;
  ANULA := cab;
end; {ANULA}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.PRIMERO : posicion;
begin
  PRIMERO := cab;
end; {PRIMERO}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
function listpi.FIN : posicion;
var
  q: posicion;
begin
  q := PRIMERO;
  while (q^.sig <> nil)  do q := q^.sig;
  FIN := q;
end; {FIN}

{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}
procedure listpi.IMPRIME (s: string) ;
var
  q, z : ptipo_celda;
begin
  if length (s) > 0 then writeln (s);
  write ('lista: ');

  q := PRIMERO ;
  z := FIN ;
  while (q <> z) do begin
    write (RECUPERA (q), ' ');
    q := SIGUIENTE (q);
  end ; {while}
  writeln ;
end; {IMPRIME}

end.
{-----+-----+-----+-----+-----+-----+-----+-----+-----+-----}