El siguiente programa mantiene una lista ordenada de enteros y permite al usuario realizar operaciones de inserción, borrado, búsqueda, desplazamiento y reordenación. Se definen dos funciones de comparación, una representa una ordenación ascendente y la otra una ordenación descendente.

Es importante tener en cuenta lo siguiente:

• En turbo-pascal, siempre que se vayan a definir subprogramas cuyas referencias se almacenen en variables de tipo procedural, es necesario incluir la directiva de compilación {$F+}
• Antes de utilizar una operación, el programa comprueba que se cumplan sus precondiciones.
• Los datos almacenados son direcciones de variables dinámicas: El programa debe encargarse de crear la variable dinámica que almacena cada uno de los datos que se inserten en la estructura (y de destruir esas variables dinámicas cuando ya no sean necesarias).

Puede descargar una copia del programa pulsando aquí.

  {$F+}
  program ejemplo1(input,output);

  { Se puede elegir entre cualquiera de las dos implementaciones,
    lista1 o lista2, el resultado debería ser el mismo. }
  uses lista1;

  type
    PEntero = ^integer;

    { Funciones de comparación }

    function OrdenAscendente(Elem1,Elem2: pointer) : boolean;
    begin
      OrdenAscendente := PEntero(Elem1)^ <= PEntero(Elem2)^
    end;

    function OrdenDescendente(Elem1,Elem2: pointer) : boolean;
    begin
      OrdenDescendente := PEntero(Elem1)^ >= PEntero(Elem2)^
    end;

    procedure EscribeLista(L: TListaOrd);
    { Escribe los enteros almacenados en la lista, resaltando el elemento actual }
    var
      Elem,ElemAct : pointer;
    begin
      ElemAct := ElemActual(L);
      { Recorre los elementos, escribiendo cada uno de ellos }
      write(output,'Lista: ');
      IrAInicio(L);
      Elem := ElemActual(L);
      while Elem <> nil do
      begin
        if Elem = ElemAct then
          { El que era el elemento actual se escribe entre corchetes. }
          write(output,' [',PEntero(Elem)^,']')
        else
          write(output,' ',PEntero(Elem)^);
        IrASiguiente(L);
        Elem := ElemActual(L)
      end;
      writeln(output);
      { Al recorrer la lista, el elemento actual ha cambiado. Con este bucle,
        se restaura el elemento actual }
      IrAInicio(L);
      while ElemActual(L) <> ElemAct do IrASiguiente(L)
    end;

  var
    Elem : PEntero;
    Lista : TListaOrd;
    Opcion : char;
    OrdenActual : (oAscendente,oDescendente);
  begin
    OrdenActual := oAscendente;
    Inicializar(Lista,OrdenAscendente);
    repeat
      EscribeLista(Lista);
      writeln(output,'[Q]:Salir [+]:Ins. [-]:Borrar [B]:Buscar [I]:Inicio [S]:Sig. [R]: Reordenar');
      write(output,'Elija opcion: ');
      readln(input,Opcion);
      case Opcion of
        '+': if ListaLlena(Lista) then
               writeln(output,'Error al insertar: Lista llena!')
             else
               begin
                 write(output,'Valor a insertar: ');
                 { Se crea la variable dinámica que almacenará el valor }
                 new(Elem);
                 { Se lee el valor directamente en la variable dinámica }
                 readln(input,Elem^);
                 Insertar(Lista,Elem)
               end;

        '-': if ElemActual(Lista) = nil then
               writeln(output,'Error al borrar: No existe elemento actual!')
             else
               begin
                 Elem := ElemActual(Lista);
                 Borrar(Lista);
                 { Atencion: Borrar un elemento de la lista NO destruye la variable dinámica en que
                   se almacena el elemento. Esa operación es responsabilidad del programa.  }
                 dispose(Elem)
               end;

        'B': begin
               write(output,'Valor a buscar: ');
               { Es necesario crear una variable dinámica almacenar el valor que se va a
                 buscar en la lista. Tras la búsqueda se destruye la variable. }
               new(Elem);
               readln(input,Elem^);
               Buscar(Lista,Elem);
               dispose(Elem)
             end;

        'I': IrAInicio(Lista);

        'S': IrASiguiente(Lista);

        'R': if OrdenActual = oAscendente then
             begin
               OrdenActual := oDescendente;
               Reordenar(Lista,OrdenDescendente)
             end else begin
               OrdenActual := oAscendente;
               Reordenar(Lista,OrdenAscendente)
             end;
      end; { case }
    until Opcion = 'Q';

    { Se destruyen los elementos de la lista. No se debe olvidar que estos
      elementos son variables dinámicas. }
    IrAInicio(Lista);
    Elem := ElemActual(Lista);
    while Elem <> nil do
    begin
      dispose(Elem);
      IrASiguiente(Lista);
      Elem := ElemActual(Lista)
    end;
    { Se libera la memoria interna ocupada por la lista }
    Destruir(Lista)
  end.