Чем отличаются между собой стек очередь или список?

program Project1;
 
type
  {Тип основных данных.}
  TData = Integer;
  {Тип указателя на элемент списка.}
  TPElem = ^TElem;
  {Тип элемента списка.}
  TElem = record
    Data : TData; {Основные данные.}
    PNext : TPElem; {Указатель на следующий элемент списка.}
  end;
  {Тип, описывающий очередь.}
  TQueue = record
    PFirst, PLast : TPElem; {Указатели на первый и на последний элементы очереди.}
  end;
  {Отдельный тип для стека описывать не будем. Стек будет представлен указателем
  на элемент, который расположен на вершине стека. Для этого достаточно типа TPElem.}
 
{------------------------------}
{Механизм очереди.}
{------------------------------}
 
{Начальная инициализация очереди. Внимание! Эту процедуру можно выполнять
только в отношении пустой очереди. Иначе будут утечки памяти.
Если очередь непуста, то следует применить вызов QFree().}
procedure QInit(var aQueue : TQueue);
begin
  aQueue.PFirst := nil;
  aQueue.PLast := nil;
end;
 
{Добавление элемента в конец очереди.}
procedure QPush(var aQueue : TQueue; const aData : TData);
var
  PNew : TPElem;
begin
  New(PNew);
  PNew^.Data := aData;
  PNew^.PNext := nil;
  if aQueue.PFirst = nil then
    aQueue.PFirst := PNew
  else
    aQueue.PLast^.PNext := PNew;
  aQueue.PLast := PNew;
end;
 
{Изъятие элемента из начала очереди. Если очередь не пуста, то
из начала очереди извлекается элемент и его значение возвращается
через параметр aData. В этом случае функция возвращает True.
Если очередь пуста, то операция отменяется и функция возвращает False.}
function QPop(var aQueue : TQueue; var aData : TData) : Boolean;
var
  PDel : TPElem;
begin
  QPop := False;
  if aQueue.PFirst = nil then Exit;
 
  PDel := aQueue.PFirst;
  aData := PDel^.Data;
  aQueue.PFirst := PDel^.PNext;
  if aQueue.PFirst = nil then aQueue.PLast := nil;
  Dispose(PDel);
  QPop := True;
end;
 
{Освобождение памяти, выделенной для очереди (очистка очереди).}
procedure QFree(var aQueue : TQueue);
var
  Data : TData;
begin
  while QPop(aQueue, Data) do;
end;
 
{------------------------------}
{Механизм стека.}
{------------------------------}
 
{Добавление элемента на вершину стека.}
procedure SPush(var aPStack : TPElem; const aData : TData);
var
  PNew : TPElem;
begin
  New(PNew);
  PNew^.Data := aData;
  PNew^.PNext := aPStack;
  aPStack := PNew;
end;
 
{Изъятие элемента с вершины стека. Если стек не пуст, то
с вершины стека извлекается элемент и его значение возвращается
через параметр aData. В этом случае функция возвращает True.
Если стек пуст, то операция отменяется и функция возвращает False.}
function SPop(var aPStack : TPElem; var aData : TData) : Boolean;
var
  PDel : TPElem;
begin
  SPop := False;
  if aPStack = nil then Exit;
 
  aData := aPStack^.Data;
  PDel := aPStack;
  aPStack := aPStack^.PNext;
  Dispose(PDel);
  SPop := True;
end;
 
{Освобождение памяти, выделенной для стека (очистка стека).}
procedure SFree(var aPStack : TPElem);
var
  Data : TData;
begin
  while SPop(aPStack, Data) do;
end;
 
{------------------------------}
{Общие процедуры.}
{------------------------------}
 
{Распечатка списка, очереди или стека. Распечатка выполняется в направлении:
Список: начало - конец.
Очередь: начало - конец.
Стек: вершина - дно.}
procedure LWriteln(aPFirst : TPElem);
var
  i : Integer;
begin
  i := 0;
  while aPFirst <> nil do begin
    Inc(i);
    if i > 1 then Write(', ');
    Write(aPFirst^.Data);
    aPFirst := aPFirst^.PNext;
  end;
  if i = 0 then
    Writeln('Нет элементов.')
  else
    Writeln;
end;
 
const
  M = 10;
var
  Q : TQueue;
  PSt : TPElem;
  Data : TData;
  i : Integer;
  S : String;
begin
  {Начальная инициализация очереди и стека.}
  QInit(Q);
  PSt := nil;
 
  repeat
    {Записываем в очередь некоторое количество элементов.}
    Randomize;
    for i := 1 to 5 + Random(M + 1) do QPush(Q, i);
 
    Writeln('------------------------------');
    Writeln('Начальное состояние.');
    Write('Очередь: ');
    LWriteln(Q.PFirst);
    Write('Стек: ');
    LWriteln(PSt);
    Writeln;
 
    {Переливаем элементы из очереди в стек.}
    while QPop(Q, Data) do SPush(PSt, Data);
 
    Writeln('Состояние после переливания элементов из очереди в стек.');
    Write('Очередь: ');
    LWriteln(Q.PFirst);
    Write('Стек: ');
    LWriteln(PSt);
    Writeln;
 
    {Переливаем элементы обратно - из стека в очередь.}
    while SPop(PSt, Data) do QPush(Q, Data);
 
    Writeln('Состояние после переливания элементов из стека в очередь.');
    Write('Очередь: ');
    LWriteln(Q.PFirst);
    Write('Стек: ');
    LWriteln(PSt);
    Writeln;
 
    {Освобождаем память, занятую под очередь и стек.}
    QFree(Q);
    SFree(PSt);
    Writeln('Память, выделенная для очереди и стека, освобождена.');
    Writeln;
 
    Writeln('Повторить - Enter, выход - любой символ + Enter.');
    Readln(S);
  until S <> '';
end.