{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA LISTA – en memoria dinamica   º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 31/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}

unit listad;

INTERFACE

type
   TElemL=integer;
   pnodo=^nodo;
   nodo=record
      dato:TElemL;
      sig:pnodo;
   end;
   tlista=record
      pri,act:pnodo;
   end;

Procedure IniciaL(var l:tlista);
Function VaciaL (l:tlista):boolean;
Procedure PrimeroL (var l:tlista);
Procedure SiguienteL(var l:tlista);
Function FinL(l:tlista):boolean;
Procedure InsertaL(var l:tlista;e:TElemL);      {inserta al medio o al final}
Procedure InsertaPpioL(var l:tlista;e:TElemL);
Procedure InsertaFinL(var l:tlista;e:TElemL);
Procedure InsertaNL(var l:tlista; e:TElemL; n:integer);
Procedure EliminaPpioL(var l:tlista);
Procedure ELiminaL(var l:tlista);

Procedure EliminaNL(var l:tlista;var e:TElemL; n:integer);
Procedure InfoL(l:tlista; var e:TElemL);
Procedure ModificaL(var l:tlista; e:TElemL);

IMPLEMENTATION

procedure IniciaL;
begin
   l.pri:=nil;
   l.act:=nil;
end;

function VaciaL;
begin
   vacial:=l.pri=nil;
end;

procedure PrimeroL;
begin
   l.act:=l.pri;
end;

procedure SiguienteL;
begin
   l.act:=l.act^.sig;
end;

function FinL;
begin
   finl:=l.act=nil;
end;

procedure InsertaL;                     {inserta al medio o al final}
var
   aux,act,ant:pnodo;
begin
   new(aux);
   aux^.dato:=e;
   if vacial(l) or (e <= l.pri^.dato) then {si vacia o < que el primero}
   begin
      aux^.sig:=l.pri;          {insertappio}
      l.pri:=aux;
   end
   else
   begin
      ant:=l.pri;
      act:=ant;
      while (act nil) and (e > act^.dato) do
      begin
         ant:=act;
         act:=act^.sig;
      end;
      ant^.sig:=aux;
      aux^.sig:=act;
   end;
end;

procedure InsertaPpioL;
var
   aux:pnodo;
begin
   new(aux);
   aux^.dato:=e;
   aux^.sig:=l.pri;
   l.pri:=aux;
end;

Procedure InsertaFinL;
var
   ant,act,aux:pnodo;
begin
   new(aux);
   aux^.dato:=e;
   ant:=l.pri;
   act:=ant;
   while act nil do
   begin
      ant:=act;
      act:=act^.sig;
   end;
   ant^.sig:=aux;
   aux^.sig:=act;
end;

procedure InsertaNL;
var
   aux,ant,act:pnodo;
   cont:integer;
begin
   new(aux);
   aux^.dato:=e;
   if n=1 then                          {si es el nodo 1}
   begin
      aux^.sig:=l.pri;
      l.pri:=aux;
   end
   else
   begin
      ant:=l.pri;
      act:=ant;
      cont:=1;
      while (act nil) and (cont < n) do
      begin
         cont:=cont+1;
         ant:=act;
         act:=act^.sig;
      end;
      ant^.sig:=aux;
      aux^.sig:=act;
   end;
end;

Procedure EliminaPpioL;
var
   aux:pnodo;
begin
   if l.prinil then
   begin
      aux:=l.pri;
      l.pri:=l.pri^.sig;
      dispose(aux);
   end;
end;

Procedure EliminaL;
var
   aux,ant:pnodo;
begin
   if l.prinil then
   begin
      if l.act=l.pri then       {si es el primer nodo}
      begin
         aux:=l.pri;
         l.pri:=l.pri^.sig;
         dispose(aux);
      end
      else
      begin
         ant:=l.pri;
         aux:=ant;
         while (aux nil) and (aux l.act) do
         begin
            ant:=aux;
            aux:=aux^.sig;
         end;
         ant^.sig:=aux^.sig;
         dispose(aux);
      end;
   end;
end;

procedure EliminaNL;
var
   aux,ant:pnodo;
   cont:integer;

begin
   if l.prinil then
   begin
      if n=1 then               {si es el primer nodo}
      begin
         e:=l.pri^.dato;
         aux:=l.pri;
         l.pri:=l.pri^.sig;
         dispose(aux);
      end
      else
      begin
         ant:=l.pri;
         aux:=ant;
         cont:=1;
         while (cont < n) and (aux nil) do
         begin
            cont:=cont+1;
            ant:=aux;
            aux:=aux^.sig;
         end;
         if aux nil then
         begin
            e:=aux^.dato;
            ant^.sig:=aux^.sig;
            dispose(aux);
         end;
      end;
   end;
end;

procedure InfoL;
begin
   e:=l.act^.dato;
end;

procedure ModificaL;
begin
   l.act^.dato:=e;
end;

end.

{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA PILA – en memoria dinamica    º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 30/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}

unit pilad;

INTERFACE

type
   TElemP=string[10];      {o cualquier tipo}
   tpila=^nodo;             {el tipo pila es un puntero a un nodo}
   nodo=record
      item:telemp;
      sig:tpila;
   end;

procedure IniciaP(var p:tpila);
procedure SacaP(var p:tpila;var e:telemp);
procedure PoneP(var p:tpila; e:telemp);
function VaciaP(p:tpila):boolean;
procedure ConsultaP(p:tpila; var e:telemp);

IMPLEMENTATION

procedure IniciaP;
begin
   p:=nil;
end;

procedure SacaP;
var
   aux:tpila;
begin
   if not vaciap(p) then
   begin
      aux:=p;                   {aux apunta a p}
      e:=p^.item;               {obtengo en e el elemento}
      p:=aux^.sig;              {p apunta al siguiente de aux}
      dispose(aux);             {devuelvo la memoria}
   end;
end;

procedure PoneP;
var
   nuevo:tpila;
begin
   new(nuevo);                  {pido memoria}
   nuevo^.item:=e;              {asigno el elemento}
   nuevo^.sig:=p;               {el siguiente del nuevo apunta a p}
   p:=nuevo;                    {p apunta al nuevo}
end;

function VaciaP;
begin
   VaciaP:=p=nil;
end;

procedure ConsultaP;
begin
   e:=p^.item;
end;

end.

{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA COLA – en memoria dinamica    º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 30/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}

unit colad;

INTERFACE

type
   TElemC=string[10];      {o cualquier tipo}
   pnodo=^nodo;
   nodo=record
      item:telemC;
      sig:pnodo;
   end;
   tcola=record
      pri,ult:pnodo;
   end;

procedure IniciaC(var c:tcola);
procedure SacaC(var c:tcola;var e:telemc);
procedure PoneC(var c:tcola; e:telemc);
function VaciaC(c:tcola):boolean;
procedure ConsultaC(c:tcola; var e:telemc);

IMPLEMENTATION

procedure IniciaC;
begin
   c.pri:=nil;
   c.ult:=nil;
end;

procedure SacaC;
var
   aux:pnodo;
begin
   if not vaciac(c) then
   begin
      e:=c.pri^.item;
      aux:=c.pri;
      if aux^.sig=nil then   {para cuando queda un elemento}
         c.ult:=nil;
      c.pri:=aux^.sig;
      dispose(aux);
   end;
end;

procedure PoneC;
var
   nuevo:pnodo;
begin
   new(nuevo);                  {pido memoria}
   nuevo^.item:=e;
   nuevo^.sig:=nil;
   if vaciac(c) then
      c.pri:=nuevo
   else
      c.ult^.sig:=nuevo;
   c.ult:=nuevo;
end;

function VaciaC;
begin
   VaciaC:=c.pri=nil;
end;

procedure ConsultaC;
begin
   e:=c.pri^.item;
end;

end.

{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA COLA – SIMPLE Y CIRCULAR      º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 16/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}
unit cola;

INTERFACE
const
   maxcola=50;
type
   telemento=char;
   tcola=record
      pri,ult:0..maxcola;
      items:array[1..maxcola] of telemento;
   end;

procedure IniciaC(var c:tcola);
function VaciaC(c:tcola):boolean;
function LlenaC(c:tcola):boolean;
procedure SacaC(var c:tcola;var elemc:telemento);
procedure PoneC(var c:tcola;elemc:telemento);
procedure ConsultaC(c:tcola; var elemc:telemento);

IMPLEMENTATION

procedure IniciaC;
begin
   c.pri:=0;
   c.ult:=0;
end;

function VaciaC;
begin
   VaciaC:=c.pri=0;
end;

{function LlenaC;
begin
   Llenac:=c.ult=maxcola;
end;}

function LlenaC;                        {CIRCULAR}
begin
   LlenaC:=((c.ult=maxcola) and (c.pri=1)) or (c.ult+1=c.pri);
end;

{procedure SacaC;
begin
   if not VaciaC(c) then
   begin
      elemc:=c.items[c.pri];
      if c.pri=c.ult then       {cuando la cola tiene un £nico elemento}
{         iniciac(c)
      else
         c.pri:=c.pri+1;
   end;
end;}

procedure SacaC;                        {CIRCULAR}
begin
   if not VaciaC(c) then
   begin
      elemc:=c.items[c.pri];
      if c.pri=c.ult then       {cuando la cola tiene un £nico elemento}
         iniciac(c)
      else
         if c.pri=maxcola then
            c.pri:=1
         else
            c.pri:=c.pri+1;
   end;
end;

{procedure PoneC;
begin
   if not LlenaC(c) then
   begin
      c.ult:=c.ult+1;
      c.items[c.ult]:=elemc;
      if c.pri=0 then           {si es el primer elemento}
{         c.pri:=1;
   end;
end;}

procedure PoneC;                        {CIRCULAR}
begin
   if not LlenaC(c) then
   begin
      if c.ult=maxcola then
         c.ult:=1               {continuo en el principio}
      else
         c.ult:=c.ult+1;
      c.items[c.ult]:=elemc;
      if c.pri=0 then           {si es el primer elemento}
         c.pri:=1;
   end;
end;

procedure ConsultaC;
begin
   if not VaciaC(c) then
      elemc:=c.items[c.pri];
end;

end.

{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA PILA – en memoria estatica    º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 11/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}
unit pila;

INTERFACE
const
   maxpila=50;
type
   telemento=char;
   tpila=record
      items:array [1..maxpila] of telemento;
      tope:0..maxpila;                        {0 para vacia}
   end;

procedure IniciaP(var p:tpila);
function VaciaP(p:tpila):boolean;
function LlenaP(p:tpila):boolean;
procedure SacaP(var p:tpila; var elemp:telemento);
procedure PoneP(var p:tpila; elemp:telemento);
procedure ConsultaP(p:tpila; var elemp:telemento);

IMPLEMENTATION

procedure IniciaP;
begin
   p.tope:=0;
end;

function VaciaP;
begin
   VaciaP:=p.tope=0;
end;

function LlenaP;
begin
   LlenaP:=p.tope=maxpila;
end;

procedure SacaP;
begin
   if not VaciaP(p) then
   begin
      elemp:=p.items[p.tope];
      p.tope:=p.tope-1;
   end;
end;

procedure PoneP;
begin
   if not LlenaP(p) then
   begin
      p.tope:=p.tope+1;
      p.items[p.tope]:=elemp;
   end;
end;

procedure ConsultaP;
begin
   if not vaciaP(p) then
      elemp:=p.items[p.tope];
end;

end.

{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
 º TDA LISTA – en memoria estatica   º
 º Desarrollado por: H. Vivani.      º
 º Universidad CAECE – Mar del Plata º
 º 11/10/2000                        º
 ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍŒ
}

unit lista;

INTERFACE
const
   maxlista=50;
type
   telemento=string;
   tlista=record
      items:array[1..maxlista] of telemento;
      cant,act:0..maxlista;
   end;

procedure IniciaL(var l:tlista);{prepara la lista para comenzar a operar}
function VaciaL(l:tlista):boolean;{verifica si est  vac¡a}
function LlenaL(l:tlista):boolean;{verifica si est  llena}
procedure PrimeroL(var l:tlista);{se posiciona al comienzo de la lista}
procedure SiguienteL(var l:tlista);{avanza al siguiente nodo de la lista}
function FinL(l:tlista):boolean;{verifica si se alcanz¢ el final de la lista}
procedure InsertaL(var l:tlista;eleml:telemento);{inserta en orden ascendente}
{procedure IncertaPpioL(var l:tlista;eleml:telemento);{inserta al principio}
{procedure InsertaFinL(var l:tlista;eleml:telemento);{inserta al final}
{procedure InsertaNL(var l:tlista;eleml:telemento;N:byte);{inserta en la N-‚sima posici¢n}
{procedure EliminaPpioL(var l:tlista);{elimia el primer noo de la lista}
{procedure EliminaL(var l:tlista);{elimina el nodo actual y avanza al siguiente}

procedure InfoL(l:tlista; var eleml:telemento);
procedure ModificaL(var l:tlista; eleml:telemento);

IMPLEMENTATION

procedure IniciaL;
begin
   l.cant:=0;
   l.act:=0;
end;

function VaciaL;
begin
   VaciaL:=l.cant=0;
end;

function LlenaL;
begin
   LlenaL:=l.cant=maxlista;
end;

procedure PrimeroL;
begin
   l.act:=1;
end;

procedure SiguienteL;
begin
   if not LlenaL(l) then
      l.act:=l.act+1;
end;

function FinL;  {detecta el fin despues de haber pasado el £ltimo (EOF)}
begin
   FinL:=l.act=l.cant+1;
end;

procedure InsertaL;     {inserta ordenado}
var
   j:0..maxlista;
begin
   if not LlenaL(l) then
   begin
      j:=l.cant;{corro los elementos desde el final h/encontrar la posicion}
      while (j>0) and (l.items[j]>eleml) do
      begin
         l.items[j+1]:=l.items[j];
         j:=j-1;
      end;
      l.items[j+1]:=eleml;      {inserto}
      l.cant:=l.cant+1;         {incremento la cantidad de elmentos}
   end;
end;

procedure InfoL;
begin
   if l.act>0 then
      eleml:=l.items[l.act];
end;

procedure ModificaL;
begin
   if l.act0 then
      l.items[l.act]:=eleml;
end;

end.