Телефонный справочник pascal

[7rubin]

Необходимо создать класс для представления телефонного справочника. Учесть, что у человека может быть несколько телефонов. Реализовать добавление, удаление, поиск информации (по номеру и по фамилии). (в консоли).
Реализовать при помощи двусвязного списка.
Желательно чтобы был класс TPhoneBook, TPerson, TName, TPhone, TLinkedList(класс для двусвяхного списка).

Буду очень благодарен за помощь.

[7rubin]

неужели вообще ничем помочь не можете?
выручите, очень надо

[Serge_Bliznykov]

вы неправильно трактуете слово "помощь". Помощь - это значит, Вы делаете, а мы Вам помогаем.
А Вы же хотите красиво отсидеться в сторонке, пока задачу будут выполнять за Вас!
с таким подходом Вам в раздел "Фриланс" надо! Там всё за Вас сделают. Вам только заплатить останется...

p.s. а задача совсем не тривиальная, пятью строчками кода не решается. Тем более, если решать её через ООП (классы, методы и т.д.)

[7rubin]

А можно-ли как-нибудь упростить данный модуль?
Сделать более красивым

unit Unit3;

interface

uses Classes, SysUtils;

type

  TCompareResult = (cLower, cEqual, cHigher);

  TData = class;

  TNameNode = class
  private
    fLeft, fRight, fParent : TNameNode;
    fOwner : TData;
  public
    property Left : TNameNode read fLeft write fLeft;
    property Right : TNameNode read fRight write fRight;
    property Parent : TNameNode read fParent write fParent;
    property Owner : TData read fOwner;
    procedure SwapChild(Old, New : TNameNode);
    constructor Create(NParent : TNameNode; Dta : TData);
    destructor Destroy;override;
  end;

  TPhoneNode = class
  private
    fLeft, fRight, fParent : TPhoneNode;
    fOwner : TData;
    fIndex : integer;
    function GetPhone : string;
  public
    property Left : TPhoneNode read fLeft write fLeft;
    property Right : TPhoneNode read fRight write fRight;
    property Parent : TPhoneNode read fParent write fParent;
    property Phone : string read GetPhone;
    property Owner : TData read fOwner;
    procedure SwapChild(Old, New : TPhoneNode);
    property Index : integer read fIndex write fIndex;
    constructor Create(NParent : TPhoneNode; NOwner : TData);
    destructor Destroy;override;
  end;

  TPhoneRec = record
    Phone : string;
    Node : TPhoneNode;
  end;

  TData = class
  private
    fName, fSurName : string;
    fPhones: array of TPhoneRec;
    fPhonesCnt : integer;
    fNameNode : TNameNode;
    procedure DelPhone(ID: integer);
    function AddPhone(Phone : string; Node : TPhoneNode) : integer;
    function GetPNode(ID : integer) : TPhoneNode;
    function GetPhone(ID: integer) : string;
    property NameNode : TNameNode read fNameNode write fNameNode;
  public
    property Name : string read fName write fName;
    property SurName: string read fSurName write fSurName;
    property Phones[i: integer] : string read GetPhone;
    property PhonesCount : integer read fPhonesCnt;
    constructor Create(NName, NSurName : string);
    destructor Destroy;override;
  end;

  TPhoneBook = class
  private
    fRoot : TNameNode;
    fPhoneRoot : TPhoneNode;
  public
    function GetbyPhone(Phn: string) : TData;
    function GetbyName(Name, SurName: string) : TData;
    function AddName(Name, SurName : string) : TData;
    procedure Delete(Node : TData);
    procedure AddPhone(Node : TData; NPhone : string);
    procedure DelPhone(Node : TData; ID : integer);
    procedure PrintAll(List : TStringList);
    constructor Create;
    destructor Destroy;override;
  end;
implementation

// higher  means that 1st is higher!!
function Compare(S1, N1, S2, N2 : string) : TCompareResult;
begin
  S1 := AnsiUpperCase( S1 );
  N1 := AnsiUpperCase( N1 );
  S2 := AnsiUpperCase( S2 );
  N2 := AnsiUpperCase( N2 );

  if (S1 > S2)or(S1 = S2)and(N1 > N2) then
    Result := cHigher
    else
    if (S1 = S2)and(N1 = N2) then
      Result := cEqual
      else
        Result := cLower;
end;

{ TData }

function TData.AddPhone(Phone : string; Node : TPhoneNode) : integer;
begin
  inc(fPhonesCnt);
  SetLength( fPhones, fPhonesCnt);
  fPhones[fPhonesCnt-1].Phone:= Phone;
  fPhones[fPhonesCnt-1].Node:= Node;
  Result:= fPhonesCnt-1;
end;

constructor TData.Create(NName, NSurName: string);
begin
  fPhonesCnt:= 0;
  fName:= NName;
  fSurName:= NSurName;
  SetLength(fPhones, 0);
end;

procedure TData.DelPhone(ID: integer);
var
  i : integer;
begin
  if (ID<0)or(ID>=fPhonesCnt) then
    exit;
  for i := ID to fPhonesCnt - 2 do
  begin
    fPhones[i]:= fPhones[i+1];
    fPhones[i].Node.Index := i;
  end;
  dec(fPhonesCnt);
  SetLength(fPhones, fPhonesCnt);
end;

destructor TData.Destroy;
begin
  inherited;
end;

function TData.GetPhone(ID: integer): string;
begin
  Result:= fPhones[ID].Phone;
end;

function TData.GetPNode(ID: integer): TPhoneNode;
begin
  Result := fPhones[ID].Node;
end;

{ TNameNode }

constructor TNameNode.Create(NParent: TNameNode; Dta: TData);
begin
  fParent:= NParent;
  fOwner:= Dta;
end;

destructor TNameNode.Destroy;
begin
  fLeft.Free;
  fRight.Free;
  fOwner.Free;
  inherited;
end;

procedure TNameNode.SwapChild(Old, New: TNameNode);
begin
  if fLeft = Old then
  begin
    fLeft := New;
    if New<>nil then New.Parent := Self;
  end
      else
      begin
        fRight := New;
        if New<>nil then New.Parent := Self;
      end;
end;

[7rubin]

///продолжение

{ TPhoneNode }

constructor TPhoneNode.Create(NParent : TPhoneNode; NOwner : TData);
begin
  fParent:= NParent;
  fIndex := 0;
  fOwner:= NOwner;
end;

destructor TPhoneNode.Destroy;
begin
  fLeft.Free;
  fRight.Free;
  inherited;
end;

function TPhoneNode.GetPhone: string;
begin
  Result:= Owner.Phones[ fIndex ];
end;

procedure TPhoneNode.SwapChild(Old, New: TPhoneNode);
begin
  if fLeft = Old then
  begin
    fLeft := New;
    if New<>nil then New.Parent := Self;
  end
      else
      begin
        fRight := New;
        if New<>nil then New.Parent := Self;
      end;
end;

{ TPhoneBook }

function TPhoneBook.AddName(Name, SurName: string): TData;
var
  Curr, Prev : TNameNode;
begin
  Curr:= fRoot.Left;
  Prev:= fRoot;
  while Curr<>nil do
  begin
    Prev:= Curr;
    if Compare(Curr.Owner.SurName, Curr.Owner.Name, SurName, Name) = cHigher then
        Curr:= Curr.Left
        else
          Curr:= Curr.Right;
  end;
  Result:= TData.Create(Name, SurName);
  Curr:= TNameNode.Create(Prev, Result);
  Result.NameNode := Curr;
  if (Prev = fRoot)or
     (Compare(Prev.Owner.SurName, Prev.Owner.Name, SurName, Name) = cHigher)then
        Prev.Left:= Curr
        else
          Prev.Right:= Curr;
end;

procedure TPhoneBook.AddPhone(Node: TData; NPhone: string);
var
  Curr, Prev : TPhoneNode;
begin
  Curr:= fPhoneRoot.Left;
  Prev:= fPhoneRoot;
  while Curr<>nil do
  begin
    Prev:= Curr;
    if( Curr.Phone > NPhone ) then
      Curr:= Curr.Left
      else
        Curr:= Curr.Right;
  end;

  Curr:= TPhoneNode.Create(Prev, Node );
  Curr.Index:=  Node.AddPhone(NPhone, Curr);
  if (Prev = fPhoneRoot)or(Prev.Phone > NPhone) then
    Prev.Left:= Curr
    else
      Prev.Right:= Curr;
end;

constructor TPhoneBook.Create;
begin
  fRoot:= TNameNode.Create(nil, nil);
  fPhoneRoot:= TPhoneNode.Create(nil, nil);
end;

procedure TPhoneBook.Delete(Node : TData);
var
  DelNode, Tmp : TNameNode;
  i : integer;
begin
  if Node<>nil then
  begin
    DelNode:= Node.NameNode;
    if DelNode<>nil then
    begin
      for i := 0 to DelNode.Owner.PhonesCount - 1 do
        DelPhone( DelNode.Owner, i );
      if(DelNode.Left = nil) then
        DelNode.Parent.SwapChild(DelNode, DelNode.Right)
        else
        if(DelNode.Right = nil) then
          DelNode.Parent.SwapChild(DelNode, DelNode.Left)
          else
          begin
            Tmp:= DelNode.Left;   // Take Left Rightmost
            while Tmp.Right<>nil do
              Tmp:= Tmp.Right;
            Tmp.Parent.SwapChild(Tmp, nil);
            DelNode.Parent.SwapChild( DelNode, Tmp );
            Tmp.Right := DelNode.Right;
            Tmp.Right.Parent := Tmp;
          end;
      DelNode.Left := nil;
      DelNode.Right := nil;
      DelNode.Free;
    end;
  end;
end;

procedure TPhoneBook.DelPhone(Node: TData; ID: integer);
var
  DelNode, Tmp : TPhoneNode;
  GoLeft : boolean;
begin
  if Node<>nil then
  begin
    DelNode := Node.GetPNode(ID);
    Node.DelPhone( ID );
    if DelNode<>nil then
      if(DelNode.Left = nil) then
        DelNode.Parent.SwapChild(DelNode, DelNode.Right)
        else
        if(DelNode.Right = nil) then
          DelNode.Parent.SwapChild(DelNode, DelNode.Left)
          else
          begin
            Tmp:= DelNode.Left;   // Take Left Rightmost
            while Tmp.Right<>nil do
              Tmp:= Tmp.Right;
            Tmp.Parent.SwapChild(Tmp, nil);
            DelNode.Parent.SwapChild( DelNode, Tmp );
            Tmp.Right := DelNode.Right;
            Tmp.Right.Parent := Tmp;
          end;
    DelNode.Left := nil;
    DelNode.Right := nil;
    DelNode.Free;
  end;
end;

destructor TPhoneBook.Destroy;
begin
  fRoot.Free;
  fPhoneRoot.Free;
  inherited;
end;

[7rubin]

////конец


function TPhoneBook.GetbyName(Name, SurName: string): TData;
var
  Curr : TNameNode;
begin
  Curr:= fRoot.Left;
  while (Curr<>nil)and (Compare(Curr.Owner.SurName, Curr.Owner.Name, SurName, Name) <> cEqual)do
      if Compare(Curr.Owner.SurName, Curr.Owner.Name, SurName, Name) = cHigher then
          Curr:= Curr.Left
          else
            Curr:= Curr.Right;
  if Curr <> nil then
    Result:= Curr.Owner
      else Result:= nil;
end;

function TPhoneBook.GetbyPhone(Phn: string): TData;
var
  Curr : TPhoneNode;
begin
  Curr := fPhoneRoot.Left;
  while (Curr<>nil)and((Curr.Phone<>Phn)) do
    if Curr.Phone > Phn then
      Curr:= Curr.Left
        else
          Curr:= Curr.Right;
  if Curr<>nil then
    Result:= Curr.Owner
    else
      Result:= nil;
end;

procedure TPhoneBook.PrintAll(List: TStringList);
  procedure Go(Node : TNameNode);
  var
    i: integer;
  begin
    if Node<>nil then
    begin
      Go(Node.Left);
      with Node.Owner do
      begin
        List.Add( SurName+' '+Name );
        for i:= 0 to PhonesCount - 1 do
          List.Add(IntToStr(i+1)+') '+Phones[i]);
        List.Add('--------');
      end;
      Go(Node.Right);
    end;
  end;
begin
    List.Clear;
  Go(fRoot.fLeft);
end;



end.

[7rubin]

Вот весь проект.

[7rubin]

Вот решения, если кому-нибудь кгода- нибудь пригодится!

buytask.ru/task765.html
buytask.ru/task766.html