2.Введение.

Деревья, у которых каждый родитель имеет не более двух сыновей называются бинарными. Они имеют унифицированную структуру, допускающую разнообразные алгоритмы прохождения эффективный доступ к элементам. Изучение бинарных деревьев даёт возможность решать наиболее общие задачи, связанные с деревьями, поскольку любое дерево общего вида можно представить эквивалентным ему бинарным деревом.

Существует несколько методов обхода деревьев: прямой, обратный и симметричный. Прямой – это обход, при котором мы посещаем узел, а затем левое и правое. Симметричный – последовательно проходить сначала левое поддерево, затем узел и правое поддерево. Обратный обход: посещение левого и правого поддерева, а затем и узел.

3. Текст исходной программы.

#include <iostream.h>

#include <stdlib.h>

#include <math.h>

#include "TreePass.h"

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

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

struct TreeNode

{ private:

TreeNodePtr Root;

TreeNodePtr LeftSub;

TreeNodePtr RightSub;

unsigned char contents;

int x,y;

public:

TreeNode(int,TreeNodePtr,TreeNodePtr,TreeNodePtr);

~TreeNode();

TreeNodePtr GetLeft(void);

TreeNodePtr GetRight(void);

void SetLeft(TreeNodePtr);

void SetRight(TreeNodePtr);

TreeNodePtr GetRoot(void);

TreeNodePtr NewNode(unsigned char,TreeNodePtr,TreeNodePtr,TreeNodePtr);

void GetValue();

void SetValue(unsigned char);

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

void PrintValue(TEdit *Dest);

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

friend class BinTree; };

struct BinTree

{ private:

TreeNodePtr TreeRoot;

TRect RT;

int cur_x,cur_y,dx,dy;

String STR;

public:

TreeNodePtr CurNode;

TreeNodePtr CreateNewNode(Direction DirSub,char Value);

TreeNodePtr GetRoot();

void SetCurrentNode(TreeNodePtr NewCur);

void SetCurrentValue(unsigned char);

void GoToTreeRoot();

void GoToNodeRoot();

int GoToLeftNode();

int GoToRightNode();

void BinTreeSymPass(TreeNodePtr strt);

void BinTreeForwardPass(TreeNodePtr strt);

void BinTreeBackwardPass(TreeNodePtr strt);

void BinTreeDraw(TreeNodePtr strt,TForm *Dest);

void BinTreeDestroy(TreeNodePtr strt);

void DeleteCurNode();

void DeleteRoot();

String GetSTR();

void ClearSTR();

BinTree(RECT nrt);

public:};

TreeNode::TreeNode(int Ncontents,TreeNodePtr NRoot,TreeNodePtr NLeft,TreeNodePtr

NRight)

{ contents=Ncontents;

Root=NRoot;

LeftSub=NLeft;

RightSub=NRight;}

TreeNode::~TreeNode()

{

}

TreeNodePtr TreeNode::GetLeft()

{ return LeftSub;}

TreeNodePtr TreeNode::GetRight()

{ return RightSub;}

TreeNodePtr TreeNode::GetRoot()

{ return TreeNode::Root;}

void TreeNode::SetLeft(TreeNodePtr NLeft)

{ LeftSub=NLeft;}

void TreeNode::SetRight(TreeNodePtr NRight)

{ RightSub=NRight;}

TreeNodePtr TreeNode::NewNode(unsigned char Ncontents,TreeNodePtr NRoot,TreeNode

Ptr NLeft,TreeNodePtr NRight)

{ TreeNodePtr NewNodePtr;

NewNodePtr = new TreeNode (Ncontents,NRoot,NLeft,NRight);

if (NewNodePtr==NULL)

{ exit(1); }

return NewNodePtr;}

void TreeNode::SetValue(unsigned char val)

{ contents=val;}

void TreeNode::PrintValue(TEdit *Dest)

{ Dest->Text+=AnsiString(contents); }

BinTree::BinTree(RECT nrt)

{ RT=nrt;

cur_x=(RT.Right-RT.Left)/2;

cur_y=RT.Top+30;

dx=cur_x/5;

TreeRoot=NULL;

CurNode=NULL; }

TreeNodePtr BinTree::CreateNewNode(Direction DirSub,char Value)

{ TreeNodePtr CurLeft=NULL,CurRight=NULL,tmp;

if (TreeRoot!=NULL)

{ if ((CurNode->LeftSub!=NULL)&&(DirSub==CLeft))

return NULL;

else

if ((CurNode->RightSub!=NULL)&&(DirSub==CRight))

return NULL; }

tmp=new TreeNode(0,CurNode,CurLeft,CurRight);

tmp->contents=0;

if (TreeRoot==NULL)

{ TreeRoot=tmp;

TreeRoot->Root=NULL;

CurNode=tmp; }

else

{ if (cur_y!=CurNode->y)

cur_y=CurNode->y;

cur_y+=30;

if (DirSub==CLeft)

{ CurNode->SetLeft(tmp);

if (cur_x!=CurNode->x)

cur_x=CurNode->x;

cur_x-=dx; }

else

if (DirSub==CRight)

{ CurNode->SetRight(tmp);

if (cur_x!=CurNode->x)

cur_x=CurNode->x;

cur_x+=dx; }

}

tmp->x=cur_x;

tmp->y=cur_y;

dx-=5;

CurNode=tmp;

CurNode->contents=Value;

return tmp;

}

void BinTree::SetCurrentValue(unsigned char val)

{ CurNode->contents=val;}

void BinTree::SetCurrentNode(TreeNodePtr NCur)

{ CurNode=NCur;}

void BinTree::GoToTreeRoot()

{ CurNode=TreeRoot;}

void BinTree::GoToNodeRoot()

{ if (CurNode->Root!=NULL)

CurNode=CurNode->Root;}

TreeNodePtr BinTree::GetRoot()

{return TreeRoot;}

int BinTree::GoToLeftNode()

{ if (CurNode->LeftSub==NULL)

return -1;

else

{ CurNode=CurNode->LeftSub;

return 0; }

}

int BinTree::GoToRightNode()

{ if (CurNode->RightSub==NULL)

return -1;

else

{ CurNode=CurNode->RightSub;

return 0; }

}

void BinTree::BinTreeSymPass(TreeNodePtr strt)

{ if (strt!=NULL)

{ BinTreeSymPass(strt->LeftSub);

STR+=char(strt->contents);

BinTreeSymPass(strt->RightSub); }

}

void BinTree::BinTreeForwardPass(TreeNodePtr strt)

{ if (strt!=NULL)

{ STR+=char(strt->contents);

BinTreeForwardPass(strt->LeftSub);

BinTreeForwardPass(strt->RightSub); }

}

void BinTree::BinTreeBackwardPass(TreeNodePtr strt)

{ if (strt!=NULL)

{ BinTreeBackwardPass(strt->LeftSub);

BinTreeBackwardPass(strt->RightSub);

STR+=char(strt->contents); }

}

void BinTree::BinTreeDraw(TreeNodePtr strt,TForm *Dest

{ if (strt!=NULL)

{ BinTreeDraw(strt->LeftSub,Dest);

Dest->Canvas->Pen->Color=clBlack;

if (strt->Root!=NULL)

{ Dest->Canvas->MoveTo(strt->Root->x,strt->Root->y);

Dest->Canvas->LineTo(strt->x,strt->y);

}

BinTreeDraw(strt->RightSub,Dest);

if (strt==CurNode) Dest->Canvas->Pen->Color=clRed;

else Dest->Canvas->Pen->Color=clBlack;

Dest->Canvas->Ellipse(strt->x-10,strt->y-10,strt->x+10,strt->y+10);

Dest->Canvas->TextOut(strt->x-4,strt->y-6,char(strt->contents));

}}

String BinTree::GetSTR()

{ return STR;}

void BinTree::ClearSTR()

{ STR="";}

void BinTree::BinTreeDestroy(TreeNodePtr strt)

{ if (strt!=NULL)

{ BinTreeDestroy(strt->LeftSub);

BinTreeDestroy(strt->RightSub);

delete strt;

strt=NULL; }

}

void BinTree::DeleteRoot()

{ TreeRoot=NULL;

cur_x=(RT.Right-RT.Left)/2;

cur_y=RT.Top+30;

dx=cur_x/5;}