Структуры данных бинарное порядоченное несбалансированное дерево

program PTree;

{$APPTYPE CONSOLE}

type

TInfo = Byte;

Item = record

Key: TInfo;

Left, Right: PItem;

TTree = class

Root: PItem;

Del(Key: TInfo);

destructor Destroy; override;

//-------------------------------------------------------------

constructor TTree.Create;

begin

Root := nil;

end;

//-------------------------------------------------------------

procedure TTree.Add(Key: TInfo);

New(P);

New(R);

R^.Key := X;

R^.Left := nil;

R^.Right := nil;

New(R);

R^.Key := X;

R^.Left := nil;

R^.Right := nil;

OK := false;

if P^.Right <> nil //правый зел не nil

InRight (P, X); //и конец

OK := true;

а

if P^.Left <> nil //левый зел не nil

InLeft(P, X); //и конец

OK := true

begin

end;

//-------------------------------------------------------------

procedure TTree.Del(Key: TInfo);

Del(var R: PItem);

st1:State w:st="on"> Del(R^.Right)

//дошли до самого правого зла

//заменить этим злом даляемый

Q^.Key := R^.Key;

Q := R;

R := R^.Left;

Delete(P^.Left, X)

if X > P^.Key then

Delete(P^.Right, X) //искать в правом поддереве

else begin

Q := P;

а

Del(Q^.Left);

Dispose(Q);

end

WriteLn('Такого элемента в дереве нет');

begin

Delete(Root, Key);

end;

//-------------------------------------------------------------

procedure TTree.View;

Write(' ');

WriteLn(R^.Key);

begin

end;

//-------------------------------------------------------------

procedure TTree.Exist(Key: TInfo);

WriteLn('Такого элемента нет');

Search (P^. Right, X)

if X < P^. Key then

Search (P^. Left, X)

else

WriteLn('Есть такой элемент');

begin

Search(Root, Key);

end;

//-------------------------------------------------------------

destructor TTree.Destroy;

Node_Dispose (P^.Left);

Node_Dispose (P^.Right);

Dispose(P);

begin

Node_Dispose(Root);

end;

//-------------------------------------------------------------

procedure InputKey(S: String; var Key: TInfo);

begin

WriteLn(S);

ReadLn(Key);

end;

ar

Tree: TTree;

N: Byte;

Key: TInfo;

begin

Tree := TTree.Create;

repeat

WriteLn('1-Добавить элемент в дерево');

WriteLn('2-Удалить элемент');

WriteLn('3-Вывести злы дерева');

WriteLn('4-Проверить существование зла');

WriteLn('5-Выход<');

ReadLn(n);

1: begin

InputKey('Введите значение добавляемого элемента', Key);

Add(Key);

2: begin

InputKey('Введите значение даляемого элемента', Key);

Del(Key);

3: View;

4: begin

InputKey('Введите элемент, существование которого вы хотите проверить', Key);

Exist(Key);

Tree.Destroy;

end.

#include <iostream.h>

#pragma hdrstop

typedef int TInfo;

typedef struct Item* PItem;

struct Item {

TInfo Key;

};

class TTree {

TTree();

(TInfo Key);

<~TTree();

};

//-------------------------------------------------------------

TTree::TTree()

{

Root = NULL;

}

//-------------------------------------------------------------

static void IniTree(PItem& P, TInfo X) //создание корня дерева

{

}

static void Iendleft (PItem& P, TInfo X) //добавление зла слева

{

R = new Item;

R->Key = X;

R->Left = NULL;

R->Right = NULL;

}

static void InRight (PItem& P, TInfo X) //добавить зел справа

{

R = new Item;

R->Key = X;

R->Left = NULL;

R->Right = NULL;

}

static void Tree_Add (PItem P, TInfo X)

{

OK = false;

else { //правый зел - лист и надо добавить к нему элемент

InRight (P, X); //и конец

OK = true;

}

else { //левый зел -лист и надо добавить к нему элемент

Iendleft(P, X); //и конец

OK = true;

}

<} //цикла while

}

oid TTree::Add(TInfo Key)

{

IniTree(Root, Key);

}

//-------------------------------------------------------------static void delete_ (PItem& P, TInfo X);

static void Del(PItem& R, PItem& Q)

//процедура даляет зел имеющий двух потомков, заменяя его на самый правый

//узел левого поддерева

{

Del(R->Right, Q);

//дошли до самого правого зла

//заменить этим злом даляемый

Q->Key = R->Key;

Q = R;

R = R->Left;

<}

} //Del

static void delete_ (PItem& P, TInfo X)

{

//Delete

delete_(P->Left, X);

delete<_(P->Right, X); //искать в правом поддереве

//узел найден, надо его далить

//сохранить ссылку на даленный зел

Q = P;

if (Q->Right == NULL)

//справа NULL

//и ссылку на зел надо заменить ссылкой на этого потомка

else

//слева NULL

//и ссылку на зел надо заменить ссылкой на этого потомка

Del(Q->Left, Q);

delete Q;

<}

}

oid TTree::Del(TInfo Key)

{

delete_(Root, Key);

}

//-------------------------------------------------------------

static void PrintTree(PItem R, TInfo L)

{

<}

}

oid TTree::View()

{

}

//-------------------------------------------------------------

static void Search(PItem& P, TInfo X)

{

<} else

Search (P-> Right, X);

Search (P-> Left, X);

cout << "Есть такой элемент" << endl;

}

oid TTree::Exist(TInfo Key)

{

Search(Root, Key);

}

//-------------------------------------------------------------

static void Node_Dispose(PItem P)

//Удаление зла и всех его потомков в дереве

{

Node_Dispose (P->Left);

Node_Dispose (P->Right);

delete P;

<}

}

TTree::~TTree()

{

Node_Dispose(Root);

}

//-------------------------------------------------------------

oid inputKey(string S, TInfo& Key)

{

}

TTree *Tree = new TTree;

int N;

TInfo Key;

int main(int argc, const char* argv[])

{

do {

<{

case 1: {

Tree->Add(Key);

<}

case 2: {

Tree-> Del(Key);

<}

case 3: Tree->View(); break;

case 4: {

Tree->Exist(Key);

<}

<}

<}

<} while (!(N==5));

return EXIT_SUCCESS;

}