Реализовать англо-русский словарь

program dynamic;
uses crt;
type
  rec = record
    num: word;
    eng: string;
    rus: string;
  end;
  pnode = ^node;
  node = record
    data : rec;
    left : pnode;
    right: pnode;
  end;
 
var
  F, Fresult: text;
 
procedure print_tree(p:pnode);
begin
  if p = nil then exit;
  with p^ do begin
    print_tree(right);
 
    write(data.eng,'    ', data.rus,'    ', data.num);
    writeln;
    write(Fresult, data.eng,'    ', data.rus,'    ', data.num);
    writeln(Fresult);
 
    print_tree(left);
  end
end;
 
procedure insert(var root: pnode; R: rec);
 
  procedure create_node(var p: pnode);
  begin
    New(p);
    p^.data := R;
    p^.Left := nil;
    p^.Right := nil
  end;
 
begin
  if root = nil then create_node(root)
  else
    with root^ do begin
      if data.eng < R.eng then insert(right, R)
      else
        if data.eng > R.eng then insert(left, R)
        else writeln('takoi element uzhe est"');
    end;
end;
 
procedure remove(var root: pnode; value: integer);
 
  procedure DeleteMin(var Root: pnode; var T: rec);
  var WasRoot: pnode;
  begin
    if Root^.Left = nil then begin
      T := Root^.data;
      WasRoot := Root;
      Root := Root^.Right;
      Dispose(WasRoot);
    end
    else DeleteMin(Root^.Left, T);
  end;
 
var
  WasNext: pnode;
  R: rec;
 
begin
  if Root <> nil then
    if Root^.data.num <> value then begin
      Remove(Root^.Left, value); Remove(Root^.right, value);
    end
    else
      if (Root^.Left = nil) and (Root^.Right = nil) then begin
        Dispose(Root); Root := nil
      end
      else
        if Root^.Left = nil then begin
          WasNext := Root^.Right;
          Dispose(Root);
          Root := WasNext;
        end
        else
          if Root^.Right = nil then begin
            WasNext := Root^.Left;
            Dispose(Root);
            Root := WasNext;
          end
          else begin
            DeleteMin(Root^.Right, R);
            Root^.data := R
          end;
end;
 
 
function max_value(r: pnode): pnode;
var
  found: pnode;
 
  procedure find_max(r: pnode);
  begin
    if r = nil then exit
    else begin
      if found^.data.num < r^.data.num then found := r;
      find_max(r^.left); find_max(r^.right);
    end;
  end;
 
begin
  if r = nil then max_value := nil
  else begin
    found := r;
    find_max(r);
    max_value := found;
  end;
end;
 
 
procedure move(p,pnew:pnode);
var p_max: pnode;
begin
  repeat
    p_max := max_value(p);
    if p_max <> nil then begin
      writeln(p_max^.data.eng);
      insert(pnew, p_max^.data);
      remove(p, p_max^.data.num);
    end;
  until p = nil;
end;
 
var
  root, rootnew: pnode;
  rec1: rec;
 
begin
  root:=nil; rootnew:=nil;
 
  Assign(F, '15_10_in.txt');
  reset(F);
  while not eof(F) do begin
    with rec1 do begin
      readln(F, num);
      readln(F, eng);
      readln(F, rus);
    end;
    insert(root, rec1);
  end;
  close(F);
 
  assign(Fresult, '15_10_out.txt');
  rewrite(Fresult);
  print_tree(root);
  move(root,rootnew);
  close(Fresult)
end.