[[Delphius]]

Bueno. Lo prometido es deuda.
me tomé unos minutos y desarrollé un ejemplo implementando una estructura LIFO. Es decir una Cola. Lo que hice es implementar una classe TABC que viene con el código encapsulado para agregar, borrar, inicializar, etc..

¿Porqué una clase?
Pues a mi me da la impresión de que quieres intentar hacer una clase por lo de:

Código Delphi [-]
function TClistletras.getletras: string; 
//...

Me he acostumbrado a codificar en Inglés o pseudoInglés... espero que no te moleste. Agregué los comentarios que me parecieron indicados exponer.

Bueno. La unidad es como sigue:

Código Delphi [-]
unit UABC;

interface

uses
  Classes;

CONST
  //Esta cadena sirve para cargar las letras
  ABC = 'ABCDEFGHIJKLMNÑOPQRSTUVWXYZ';

type
  // estructura de un nodo
  TNode = ^Node;
  Node = record
          Character: char;
          Sig: TNode;
         end;

  // Estructura de una clase que opera con una estructura LIFO (Cola)
  // para armar un abecedario
  // Debido a la simpleza de implementar una estructura LIFO
  // se optó por este método
  // Por tanto Z será el último elemento de la pila, y A el primero

  // De forma análoga se puede conseguir mediante FIFO o una lista genérica
  TABC = class
    private
      // Nuestro TOPE
      Ftop: TNode;

      // Inicilizar cola
      procedure Init;

      // Borrar o Limpiar cola
      procedure Clear;
    public
      constructor Create;
      destructor Destroy;

      // Push = Agregar
      procedure Push(Character: char);

      // Pop = Eliminar
      function Pop: char;

      // IsEmpty = EsVacia
      function IsEmpty: boolean;

      // DevolverCaracter (no lo elimina, solo consulta)
      function GetChar: char;
  end;


implementation

procedure TABC.Push(Character: char);
var NewNode: TNode;
begin
  new(NewNode);
  NewNode.Character := Character;
  NewNode.Sig := Nil;

  if IsEmpty
     then begin
            // No tenía nodo
            // NuevoNode es el primero
            Ftop.Sig := NewNode;
          end
     else begin
            // Hay más de un nodo
            // TOPE siempre apunta al último nodo
            NewNode.Sig := FTop.Sig;
            FTop.Sig := NewNode;
          end;
end;

function TABC.Pop: char;
var OldNode: TNode;
begin
  if NOT IsEmpty
     then begin
          OldNode := FTop.Sig;

          // devolvemos el carater del elemento TOPE
          result := OldNode.Character;

          // Eliminamos el elemento tope y TOPE apunta al siguiente en la
          // cola
          FTop.Sig := OldNode.Sig;
          dispose(OldNode);
          end;
end;

constructor TABC.Create;
begin
  // reservamos el TOPE
  new(FTop);
  FTop.Sig := Nil;

  // Iniciamos la cola...
  Init;
end;

destructor TABC.Destroy;
begin
  // Borramos la cola
  Clear;

  dispose(FTop);
end;

procedure TABC.Init;
var Pos: integer;
begin
 // desde 1 hasta la longitud de la cadena ABC
 for Pos := 1 to Length(ABC) do
   // metemos en la pila el caracter Pos-ésimo de la cadena ABC
   Push(ABC[Pos]);
end;

procedure TABC.Clear;
var Node: TNode;
begin
  while NOT IsEmpty do
    Pop;
end;

function TABC.IsEmpty: boolean;
begin
  // TRUE si TOPE no apunta nada
  // FALSE en cualquier otro caso
  result := FTop.Sig = Nil;
end;

function TABC.GetChar: char;
begin
  if NOT IsEmpty
     then result := FTop.Sig.Character;
end;

end.

Un ejemplo de uso, cargando un ListBox:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var ABCobj: TABC;
    i: integer;
begin
 ABCobj := TABC.Create;

 for i := 1 to 27 do
   ListBox1.Items.insert(0,ABCobj.pop);
 Application.ProcessMessages;

 ABCobj.Destroy;
end;

Creería que con eso puedes darte una idea de como implementarlo con otras estructuras, por ejemplo FIFO.

Si tienes dudas, avisa.
Saludos,

PD: Si algún moderador pasa por aquí, que mueva a este hilo a la sección adecuada ya que el tema no correspondería al subforo Internet.