Переместить элементы из одного стека в другой

uses crt;
type
   TMyType = integer;
   TStack = ^TNode;
   TNode = record
      value: TMyType;
      next: TStack;
   end;
{-----------------------------------------------}
{Занесение элемента в стек}
procedure Push(var theStack: TStack; theValue: TMyType);
var
   node: TStack;
begin
   new(node);
   node^.value := theValue;
   node^.next := theStack;
   theStack := node;
end;
{-----------------------------------------------}
{Вывод наэкран всех элементов стека}
procedure Print(theStack: TStack);
var
   node: TStack;
begin
   node := theStack;
 
   while (node <> nil) do
   begin
      write(node^.value:3);
      node := node^.next;
   end;
 
   writeln;
end;
{-----------------------------------------------}
{Формирование стека заданной длинны. Формируется случайным образом}
procedure PushRandomValue(var theStack: TStack; theCount: word);
var
   i: byte;
begin
   theStack := nil;
 
   for i:= 1 to theCount do
   begin
      Push(theStack, random(2*theCount) + 1);
   end;
end;
{-----------------------------------------------}
{Перемещение элементов одного стека в другой}
procedure Move(var theStackTo, theStackFrom: TStack);
var
   node: TStack;
begin
   while (theStackFrom <> nil) do
   begin
      node := theStackFrom;
      theStackFrom := theStackFrom^.next;
      node^.next := theStackTo;
      theStackTo := node;
   end;
end;
{-----------------------------------------------}
var
  stack1, stack2: TStack;
begin
   randomize;
   PushRandomValue(stack1, random(7) + 3);
   PushRandomValue(stack2, random(7) + 3);
 
   write('[1] : ');
   Print(stack1);
   write('[2] : ');
   Print(stack2);
   writeln;
 
   Move(stack2, stack1);
 
   write('[1] : ');
   Print(stack1);
   write('[2] : ');
   Print(stack2);
end.

program Project1;
 
type
  //Тип основных данных.
  TData = Integer;
 
  //Указатель на элемент стека.
  TPElem = ^TElem;
  //Элемент стека.
  TElem = record
    Data : TData;
    PNext : TPElem;
  end;
 
//Добавление элемента на вершину стека.
procedure StackPush(var aPStack, aPElem : TPElem);
begin
  if aPElem = nil then Exit;
  aPElem^.PNext := aPStack;
  aPStack := aPElem
end;
 
//Изъятие элемента с вершины стека.
//Если стек не пуст, то с вершины стека изымается элемент и возвращается
//через параметр aPElem. В этом случае, функция возвращает значение True.
//Если стек пуст, то операция отменяется, а функция возвращает значение False.
function StackPop(var aPStack, aPElem : TPElem) : Boolean;
begin
  StackPop := False;
  if aPStack = nil then Exit;
  aPElem := aPStack;
  aPStack := aPElem^.PNext;
  StackPop := True;
end;
 
//Удаление стека из памяти (очистка стека).
procedure StackFree(var aPStack : TPElem);
var
  PElem : TPElem;
begin
  while StackPop(aPStack, PElem) do Dispose(PElem);
end;
 
//Распечатка стека в направлении вершина - дно.
procedure StackPrint(var aPStack : TPElem);
var
  PSt, PElem : TPElem;
  i : Integer;
begin
  if aPStack = nil then begin
    Writeln('Стек пуст.');
    Exit;
  end;
  //Начальная инициализация вспомогательного стека.
  PSt := nil;
  //Переливаем все элементы стека aPStack в стек PSt и выполняем распечатку.
  i := 0;
  while StackPop(aPStack, PElem) do begin
    StackPush(PSt, PElem);
    Inc(i);
    if i > 1 then Write(', ');
    Write(PElem^.Data);
  end;
  Writeln;
  //Возвращаем элементы из стека PSt в стек aPStack. При этом, элементы
  //в стеке aPStack окажутся в том же порядке, в каком они были до распечатки.
  while StackPop(PSt, PElem) do StackPush(aPStack, PElem);
end;
 
const
  //Глубина стека.
  M = 10;
var
  PSt1, PSt2, PElem : TPElem;
  i : Integer;
  S : String;
begin
  //Начальная инициализация стеков.
  PSt1 := nil;
  PSt2 := nil;
 
  repeat
    //Формируем содержимое первого стека.
    Randomize;
    for i := 1 to M do begin
      New(PElem);
      PElem^.Data := Random(10); //0..9.
      StackPush(PSt1, PElem);
    end;
 
    //Распечатка стеков.
    Writeln('Первый стек:');
    StackPrint(PSt1);
    Writeln('Второй стек:');
    StackPrint(PSt2);
 
    //Переливаем все элементы стека PSt1 в стек PSt2.
    while StackPop(PSt1, PElem) do StackPush(PSt2, PElem);
 
    //Распечатка стеков.
    Writeln('Выполнено переливание из певого стека - во второй.');
    Writeln('Первый стек:');
    StackPrint(PSt1);
    Writeln('Второй стек:');
    StackPrint(PSt2);
 
    //Удаление стеков из памяти.
    StackFree(PSt1);
    StackFree(PSt2);
    Writeln('Работа завершена. Стеки удалёны из памяти.');
 
    Writeln('Повторить - Enter. Выход - любой символ + Enter.');
    Readln(S);
  until S <> '';
end.

program Project1;
 
const
  //Наибольшая глубина стека. Т. е. максимальное количество элементов,
  //которое может поместиться в стек.
  StSizeMax = 30;
 
type
  //Тип, описывающий стек.
  TStack = record
    //Указатель вершины стека. Это индекс последнего добавленного элемента.
    Pnt : Integer;
    //Контейнер данных стека.
    Data : array[1..StSizeMax] of Integer;
  end;
 
//Добавить элемент на вершину стека.
function StackPush(var aSt : TStack; const aNum : Integer) : Boolean;
begin
  StackPush := False;
  if not (aSt.Pnt < High(aSt.Data)) then Exit;
  //Индекс добавляемого элемента.
  Inc(aSt.Pnt);
  //Добавляем элемент в массив (т. е. в стек).
  aSt.Data[aSt.Pnt] := aNum;
  StackPush := True;
end;
 
//Взять элемент с вершины стека.
function StackPop(var aSt : TStack; var aNum : Integer) : Boolean;
begin
  StackPop := False;
  if aSt.Pnt < Low(aSt.Data) then Exit;
  aNum := aSt.Data[aSt.Pnt];
  Dec(aSt.Pnt);
  StackPop := True;
end;
 
//Удаление стека из памяти (очистка стека).
procedure StackInit(var aSt : TStack);
begin
  aSt.Pnt := Low(aSt.Data) - 1;
end;
 
//Распечатка стека.
procedure StackPrint(var aSt : TStack);
var
  St : TStack;
  Elem : Integer;
  i : Integer;
begin
  if aSt.Pnt < Low(aSt.Data) then begin
    Writeln('Стек пуст.');
    Exit;
  end;
  //Инициализация вспомогательного стека.
  StackInit(St);
  //Переливаем все элементы стека aSt в стек St и выполняем распечатку.
  i := 0;
  while StackPop(aSt, Elem) do begin
    StackPush(St, Elem);
    Inc(i);
    if i > 1 then Write(', ');
    Write(Elem);
  end;
  Writeln;
  //Возвращаем элементы из стека St в стек aSt. При этом, элементы
  //в стеке aSt окажутся в том же порядке, в каком они были до распечатки.
  while StackPop(St, Elem) do StackPush(aSt, Elem);
end;
 
const
  //Глубина стека.
  M = 10;
var
  St1, St2 : TStack;
  i, Elem : Integer;
  S : String;
begin
  //Инициализация стеков.
  StackInit(St1);
  StackInit(St2);
 
  repeat
    //Формируем содержимое стека.
    Randomize;
    for i := 1 to M do begin
      if not StackPush(St1, Random(10)) then begin
        Writeln('Переполнение стека. Всего записано элементов: ', i - 1);
        Break;
      end;
    end;
 
    //Распечатка стеков.
    Writeln('Первый стек:');
    StackPrint(St1);
    Writeln('Второй стек:');
    StackPrint(St2);
 
    //Переливаем все элементы стека PSt1 в стек PSt2.
    while StackPop(St1, Elem) do StackPush(St2, Elem);
 
    //Распечатка стеков.
    Writeln('Выполнено переливание из певого стека - во второй.');
    Writeln('Первый стек:');
    StackPrint(St1);
    Writeln('Второй стек:');
    StackPrint(St2);
 
    //Здесь удаление стеков из памяти не трубется, так как стеки реализованы
    //на статических массивах. Но, тем не менее, для общности подхода
    //выполним очистку стеков.
    StackInit(St1);
    StackInit(St2);
    Writeln('Работа завершена. Стеки обнулены.');
 
    Writeln('Повторить - Enter. Выход - любой символ + Enter.');
    Readln(S);
  until S <> '';
end.