Файловый архив студентов. Файловый архив студентов.
1259 вузов, 4592 предметов.
/ Регистрация
FAQ Обратная связь Вопросы и предложения
Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Санкт-Петербургский государственный электротехнический университет "ЛЭТИ"
Предмет:
Программирование
Файл:

Бинарные деревья на языке Паскаль / BINTREE

.TXT
Скачиваний:
8
Добавлен:
01.05.2014
Размер:
28.95 Кб
Скачать
☆

1) ‡Ђ„Ђ—Ђ.
ђҐ «Ё§®ў вм ЇаҐ¤бв ў«Ґ­ЁҐ ў ¤Ё­ ¬ЁзҐбЄ®© Ї ¬пвЁ Ё Ў §®ўлҐ
®ЇҐа жЁЁ ­ ¤ ЎЁ­ а­л¬Ё ¤ҐаҐўмп¬Ё ­  Turbo Pascal-e Ё ‘++.

2) ЉЋЊЊ…Ќ’Ђђ€€ Љ ђЂЃЋ’….
Љ ®взҐвг ЇаЁ« Ј овбп Їа®Ј а¬¬л ­ е®¤пйЁҐбп ў ¤ЁаҐЄв®аЁЁ BINTREE.
‚ ¤ЁаҐЄв®аЁЁ ...\BINTREE\TP ­ е®¤пвбп Їа®Ја ¬¬л ­ ЇЁб ­­лҐ ­ 
Turbo Pascal-e :

bintree .pas - ¬®¤г«м б ॠ«Ё§ жЁҐ© Ў §®ўле ®ЇҐа жЁ© ­ ¤ ЎЁ­ а­л¬Ё
¤ҐаҐўмп¬Ё
globalbt.pas - ¬®¤г«м б ®ЇЁб ­ЁҐ¬ вЁЇ  н«Ґ¬Ґ­в®ў ¤ҐаҐў 
testbt .pas - Їа®Ја ¬¬  вҐбвЁагой п ¬®¤г«м, ў Є®в®а®© ॠ«Ё§®ў ­л
ЇаЁ¬Ґал Їа®жҐ¤га а Ў®в ойЁе б ЎЁ­ а­л¬Ё ¤ҐаҐўмп¬Ё
intestbt.txt - ўе®¤­®© д ©« ¤«п ®¤­®Ј® Ё§ ЇаЁ¬Ґа®ў

‚ ¤ЁаҐЄв®аЁЁ ...\BINTREE\BC ­ е®¤пвбп Їа®Ја ¬¬л ­ ЇЁб ­­лҐ ­ 
C++ :

bintree .h - ¬®¤г«м б ॠ«Ё§ жЁҐ© Ў §®ўле ®ЇҐа жЁ© ­ ¤ ЎЁ­ а­л¬Ё
¤ҐаҐўмп¬Ё
globalbt.h - ¬®¤г«м б ®ЇЁб ­ЁҐ¬ вЁЇ  н«Ґ¬Ґ­в®ў ¤ҐаҐў 
testbt .cpp - Їа®Ја ¬¬  вҐбвЁагой п ¬®¤г«м, ў Є®в®а®© ॠ«Ё§®ў ­л
ЇаЁ¬Ґал Їа®жҐ¤га а Ў®в ойЁе б ЎЁ­ а­л¬Ё ¤ҐаҐўмп¬Ё
intestbt.txt - ўе®¤­®© д ©« ¤«п ®¤­®Ј® Ё§ ЇаЁ¬Ґа®ў

Џђ€Њ…—ЂЌ€…: ‘®®вўҐвбвўгойго бЇҐжЁдЁЄ жЁо ¤«п ЎЁ­ а­ле ¤ҐаҐўмҐў ¬®¦­®
­ ©вЁ ў Їа ЄвЁ¬г¬Ґ Ї® Їа®Ја ¬¬Ёа®ў ­Ёо

"„Ё­ ¬ЁзҐбЄЁҐ бвагЄвгал ¤ ­­ле"

Ђўв®ал: Ђ«ҐЄбҐҐў Ђ.ћ.
€ў ­®ўбЄЁ© ‘.Ђ.
Љг«ЁЄ®ў „.‚.

ЃЁЎ«Ё®вҐЄ  ќ’“.

3) ЏђѓђЂЊЊ› ‘ ђ…Ђ‹€‡Ђ–€…‰ Ѓ€ЌЂђЌ›• „…ђ…‚њ…‚:
--------------------------------------------------------------------------
GLOBALBT.PAS

Unit GlobalBT;
INTERFACE
type
Elem=char;
IMPLEMENTATION
begin
end.
--------------------------------------------------------------------------
BINTREE.PAS

Unit BinTree;
INTERFACE
uses GlobalBT;
const
NilBT=nil;
type
BinT=^Node; { ЇаҐ¤бв ў«Ґ­ЁҐ ЎЁ­ а­®Ј® ¤ҐаҐў  }
{ вЁЇ Elem ®ЇЁб ­ ў ¬®¤г«Ґ GlobalBT }
Node=record { 㧥«: }
Info:Elem; { = ᮤҐа¦Ё¬®Ґ }
LSub:BinT; { = «Ґў®Ґ Ї®¤¤ҐаҐў® }
RSub:BinT; { = Їа ў®Ґ Ї®¤¤ҐаҐў® }
end;{ Node }

function CreateBt :BinT;
{ ᮧ¤ вм Їгб⮥ ¤ҐаҐў®}

function NullBT ( t:BinT ) :Boolean;
{Їа®ўҐаЁвм ¤ҐаҐў® ­  Їгбв®вг}

function RootBT ( t:BinT ) :Elem;
{ўл¤Ґ«Ёвм Є®аҐ­м ¤ҐаҐў 
®вЄ § - Null
Pred: not Null(t) }

function LeftBT ( t:BinT ) :BinT;
{ўл¤Ґ«Ёвм «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null
Pred: not Null(t) }

function RightBT ( t:BinT ) :BinT;
{ўл¤Ґ«Ёвм Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null
Pred: not Null(t) }

function ConsBT ( e:Elem; LS,RS :BinT ) :BinT;
{Є®­бвагЄв®а
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в }

procedure DestroyBT ( var b: BinT);
{®зЁбвЁвм Ї ¬пвм § ­Ё¬ Ґ¬го н«Ґ¬Ґ­в ¬Ё ¤ҐаҐў }

procedure Otkaz ( n : Byte );
{ўлўҐбвЁ б®®ЎйҐ­ЁҐ ЇаЁ Ї®ЇлвЄҐ ўлЇ®«­Ґ­Ёп
­Ґ¤®ЇгбвЁ¬ле ®ЇҐа жЁ© Ё § ўҐаиЁвм а Ў®вг Їа®Ја ¬¬л}

{-------------------------------------------------------------------------}
function MakeRoot ( e :Elem ) :BinT;
{ᮧ¤ вм Є®аҐ­м ¤ҐаҐў 
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в }

procedure SetLeft ( e :Elem; b:BinT );
{Ї®¤ўҐбЁвм ­®ўл© 㧥« ў «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, Null(LeftBT)
Pred: ( not Null(t) ) & ( Null( LeftBT(t) ) )}

procedure SetRight ( e :Elem; b:BinT );
{Ї®¤ўҐбЁвм ­®ўл© 㧥« ў Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, Null(RightBT)
Pred: ( not Null(t) ) & ( Null( RightBT(t) ) )}
{-------------------------------------------------------------------------}
IMPLEMENTATION

procedure Otkaz ( n : Byte );
{ ўлўҐбвЁ б®®ЎйҐ­ЁҐ ЇаЁ Ї®ЇлвЄҐ ўлЇ®«­Ґ­Ёп
­Ґ¤®ЇгбвЁ¬ле ®ЇҐа жЁ© Ё § ўҐаиЁвм а Ў®вг Їа®Ја ¬¬л }
begin
Writeln;
Case n of
1 : Writeln( 'Ћ’ЉЂ‡ : RootBT( Null_Bin_Tree ) !');
2 : Writeln( 'Ћ’ЉЂ‡ : LeftBT( Null_Bin_Tree ) !');
3 : Writeln( 'Ћ’ЉЂ‡ : RightBT( Null_Bin_Tree ) !');
4 : Writeln( 'Ћ’ЉЂ‡ : ЁбзҐаЇ ­  Ї ¬пвм !');
5 : Writeln( 'Ћ’ЉЂ‡ : SetLeft( Null_Bin_Tree )');
6 : Writeln( 'Ћ’ЉЂ‡ : SetLeft( Not ( Null_Bin_Tree ( LeftBT ) ) )');
7 : Writeln( 'Ћ’ЉЂ‡ : SetRight( Null_Bin_Tree )');
8 : Writeln( 'Ћ’ЉЂ‡ : SetRight( Not ( Null_Bin_Tree ( RightBT ) ) )');
else Writeln( 'Ћ’ЉЂ‡ : ?');
end;
{Halt;} { гЎа ­ ¤«п вҐбвЁа®ў ­Ёп !!!!!!}
end{ Otkaz };

function CreateBT :BinT;
{ᮧ¤ вм Їгб⮥ ¤ҐаҐў®}
begin
CreateBT:=nil;
end{ CreateBT };

function NullBT ( t:BinT ) :Boolean;
{Їа®ўҐаЁвм ¤ҐаҐў® ­  Їгбв®вг}
begin
NullBT:=( t=nil);
end{ NullBT };

function RootBT ( t:BinT ) :Elem;
{ўл¤Ґ«Ёвм Є®аҐ­м ¤ҐаҐў 
®вЄ § - Null}
begin
if t <> nil then RootBT:=t^.Info else Otkaz(1);
end{ RootBT };

function LeftBT ( t:BinT ) :BinT;
{ўл¤Ґ«Ёвм «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null}
begin
if t <> nil then LeftBT:=t^.LSub else Otkaz(2);
end{ LeftBT };

function RightBT ( t:BinT ) :BinT;
{ўл¤Ґ«Ёвм Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null}
begin
if t <> nil then RightBT:=t^.RSub else Otkaz(3);
end{ RightBT };

function ConsBT ( e:Elem; LS,RS :BinT ) :BinT;
{Є®­бвагЄв®а
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в }
var b : BinT;
begin
if MaxAvail >= SizeOf(Node) then
begin
New( b );
b^.Info:=e; b^.LSub:=LS; b^.RSub:=RS;
ConsBT:=b;
end
else Otkaz(4);
end{ ConsBT };

procedure DestroyBT ( var b: BinT );
{®зЁбвЁвм Ї ¬пвм § ­Ё¬ Ґ¬го н«Ґ¬Ґ­в ¬Ё ¤ҐаҐў }
begin
if b <> nil then
begin
DestroyBT( b^.LSub ); DestroyBT( b^.RSub );
Dispose( b );
end;
end{ DestroyBT };

{----------------„®Ї®«­ЁвҐ«м­лҐ дг­ЄжЁЁ-----------------------------------}
function MakeRoot ( e :Elem ) :BinT;
{ ᮧ¤ вм Є®аҐ­м ¤ҐаҐў 
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в }
var b :BinT;
begin
if MaxAvail >= SizeOf(Node) then
begin
New( b );
b^.Info:=e; b^.LSub:=nil; b^.RSub:=nil;
MakeRoot:=b;
end
else Otkaz(4);
end{ MakeRoot };

procedure SetLeft ( e :Elem; b:BinT );
{ Ї®¤ўҐбЁвм ­®ўл© 㧥« ў «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, not Null(LeftBT) }
begin
if NullBT( b ) then Otkaz( 5 )
else if NullBT( LeftBT( b ) ) then b^.LSub:=MakeRoot(e)
else Otkaz(6);
end{ SetLeft };

procedure SetRight ( e :Elem; b:BinT );
{ Ї®¤ўҐбЁвм ­®ўл© 㧥« ў Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, not Null(RightBT) }
begin
if NullBT( b ) then Otkaz( 7 )
else if NullBT( RightBT( b ) ) then b^.RSub:=MakeRoot(e)
else Otkaz(8);
end{ SetRight };

end.

============================================================================
GLOBALBT.H

typedef char Elem;
--------------------------------------------------------------------------
BINTREE.H

#include"globalbt.h"
#include<stdio.h>
#include<stdlib.h>

struct Node // 㧥«:
{ Elem Info; // = ᮤҐа¦Ё¬®Ґ
Node *LSub; // = «Ґў®Ґ Ї®¤¤ҐаҐў®
Node *RSub; // = Їа ў®Ґ Ї®¤¤ҐаҐў®
};// Node
typedef Node *BinT;
void Otkaz ( int n )
// ўлўҐбвЁ б®®ЎйҐ­ЁҐ ЇаЁ Ї®ЇлвЄҐ ўлЇ®«­Ґ­Ёп
// ­Ґ¤®ЇгбвЁ¬ле ®ЇҐа жЁ© Ё § ўҐаиЁвм а Ў®вг Їа®Ја ¬¬л
{
printf("\n");
switch (n)
{case 1 : printf( "Ћ’ЉЂ‡ : RootBT( Null_Bin_Tree ) !");break;
case 2 : printf( "Ћ’ЉЂ‡ : LeftBT( Null_Bin_Tree ) !");break;
case 3 : printf( "Ћ’ЉЂ‡ : RightBT( Null_Bin_Tree ) !");break;
case 4 : printf( "Ћ’ЉЂ‡ : ЁбзҐаЇ ­  Ї ¬пвм !");break;
case 5 : printf( "Ћ’ЉЂ‡ : SetLeft( Null_Bin_Tree )");break;
case 6 : printf( "Ћ’ЉЂ‡ : SetLeft( Not ( Null_Bin_Tree ( LeftBT ) ) )");break;
case 7 : printf( "Ћ’ЉЂ‡ : SetRight( Null_Bin_Tree )");break;
case 8 : printf( "Ћ’ЉЂ‡ : SetRight( Not ( Null_Bin_Tree ( RightBT ) ) )");break;
default: printf( "Ћ’ЉЂ‡ : ?");
}
//exit(1);гЎа ­ ¤«п вҐбвЁа®ў ­Ёп!!!!
}// Otkaz

BinT CreateBT()
//ᮧ¤ вм Їгб⮥ ¤ҐаҐў®
{ return 0; }//CreateBT

int NullBT ( BinT t )
//а®ўҐаЁвм ¤ҐаҐў® ­  Їгбв®вг
{ return ( t==0 );}// NullBT

Elem RootBT ( BinT t )
// ўл¤Ґ«Ёвм Є®аҐ­м ¤ҐаҐў 
// ®вЄ § - Null
// Pred: not Null(t)
{ if ( t ) return( t->Info ); else Otkaz(1); return 0; }// RootBT

BinT LeftBT ( BinT t )
/* ўл¤Ґ«Ёвм «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null}
Pred: not Null(t) */
{ if ( t ) return( t->LSub ); else Otkaz(2); return 0; }// LeftBT

BinT RightBT ( BinT t )
/* ўл¤Ґ«Ёвм Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - Null
Pred: not Null(t) */
{ if ( t ) return( t->RSub ); else Otkaz(3); return 0;}// RightBT


BinT ConsBT ( Elem e, BinT LS, BinT RS )
/* Є®­бвагЄв®а
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в */

{ BinT b=new( Node );
b->Info=e; b->LSub=LS; b->RSub=RS;
return ( b );
//else Otkaz(4);
}// ConsBT

void DestroyBT ( BinT &b )
//®зЁбвЁвм Ї ¬пвм § ­Ё¬ Ґ¬го н«Ґ¬Ґ­в ¬Ё ¤ҐаҐў 
{if ( b )
{ DestroyBT ( b->LSub );
DestroyBT ( b->RSub );
delete ( b );
}
}//DestroyBT

//----------------„®Ї®«­ЁвҐ«м­лҐ дг­ЄжЁЁ-----------------------------------
BinT MakeRoot ( Elem e )
/* ᮧ¤ вм Є®аҐ­м ¤ҐаҐў 
®вЄ § - ­Ґ еў в Ґв Ї ¬пвЁ ¤«п ­®ў®Ј® н«Ґ¬Ґ­в */
{ BinT b=new( Node );
b->Info=e; b->LSub=0; b->RSub=0;
return b;
// else Otkaz(4);
}// MakeRoot

void SetLeft ( Elem e, BinT b )
/* Ї®¤ўҐбЁвм ­®ўл© 㧥« ў «Ґў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, not Null(LeftBT)
Pred: ( not Null(t) ) & ( Null( LeftBT(t) ) )} */
{ if ( !b ) Otkaz(5);
else if ( !LeftBT( b ) ) b->LSub=MakeRoot ( e );
else Otkaz(6);
}// SetLeft

void SetRight ( Elem e, BinT b )
/* Ї®¤ўҐбЁвм ­®ўл© 㧥« ў Їа ў®Ґ Ї®¤¤ҐаҐў®
®вЄ § - not Null, not Null(RightBT)
Pred: ( not Null(t) ) & ( Null( RightBT(t) ) )*/
{ if ( !b ) Otkaz(7);
else if ( !RightBT( b ) ) b->RSub=MakeRoot ( e );
else Otkaz(8);
}// SetRight

============================================================================

4) ’…‘’€ђ“ћ™€… ЏђЋѓђЂЊЊ›.
--------------------------------------------------------------------------
TESTBT.PAS

Uses BinTree,crt,GlobalBT;
var Fin : Text;
b,temp :BinT;
e:Elem;
function EnterBT :BinT;
{ ўў®¤ 㧫®ў ў Љ‹Џ-Ї®ап¤ЄҐ Ё Ї®бв஥­ЁҐ ЎЁ­ а­®Ј® ¤ҐаҐў }
var c:char;
begin
Read( Fin, c);
if c='/'
then EnterBT:=NilBT
else EnterBT:=ConsBT ( c,EnterBT,EnterBT);
end{ EnterBT };

procedure OutBT( b :BinT );
{ ўлў®¤ 㧫®ў ЎЁ­ а­®Ј® ¤ҐаҐў  ў Љ‹Џ-Ї®ап¤ЄҐ }
begin
if not NullBT( b )
then
begin
Write( RootBT(b) );
OutBT( LeftBT( b ) );
OutBT( RightBT( b ) );
end
else Write('/');
end{ EnterBT };

procedure DisplayBT( b :BinT);
{ ўлў®¤ Ї®бва®з­®Ј® Ё Ї®ўҐа­гв®Ј® Ё§®Ўа ¦Ґ­Ёп ЎЁ­ а­®Ј® ¤ҐаҐў 
б ў®§ўа в®¬ Є®аҐвЄЁ }
begin
if NullBT ( b ) then { ? }
else
begin
Write( RootBT( b ) );
if not NullBT( RightBT( b ) ) then
begin
Write(' '); { ўЇа ў® }
DisplayBT( RightBT( b ) );
Write(#8); Write(#8); { ў®§ўа в ў«Ґў® }
end;
if not NullBT( LeftBT( b ) ) then
begin
Write(#10); { ў­Ё§ }
Write(' '); { ўЇа ў® }
DisplayBT( LeftBT( b ) );
Write(#8); Write(#8); { ў®§ўа в ў«Ґў® }
end;
end;{ else }
end{ DisplayBT };

procedure DisplayBT1( b :BinT; n :integer);
{ ўлў®¤ Ї®бва®з­®Ј® Ё Ї®ўҐа­гв®Ј® Ё§®Ўа ¦Ґ­Ёп ЎЁ­ а­®Ј® ¤ҐаҐў 
ЎҐ§ ў®§ўа в  Є®аҐвЄЁ }
{ n - га®ўҐ­м 㧫  }
var i:integer;
begin
if NullBT (b) then {Writeln}
else
begin
Write( ' ',RootBT( b ));
if NullBT(RightBT(b))
then Writeln { ў­Ё§ }
else DisplayBT1( RightBT(b), n+1);
if not NullBT(LeftBT(b))
then
begin
for i:=1 to n do write(' '); { ўЇа ў® }
DisplayBT1( LeftBT(b), n+1);
end;
end;
end{ DisplayBT1 };

{-------------Џа楤гал ЁбЇ®«м§гҐ¬лҐ ЇаЁ вҐбвЁа®ў ­ЁЁ------------------------}
procedure TNull( b :BinT);
{вҐбвЁагҐв NullBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('NullBT : „ҐаҐў® ');
if not NullBT( b ) then write('­Ґ ');
writeln('Їгбв®.');
write('BT=');
DisplayBT( b);writeln;
readkey;
end{TNull};

procedure TRoot( b :BinT);
{вҐбвЁагҐв RootBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('RootBT :',RootBT( b ));writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
end{TRoot};

procedure TLeft( b :BinT);
{вҐбвЁагҐв LeftBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('LeftBT :');
DisplayBT( LeftBT( b ));writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
end{TLeft};

procedure TRight( b :BinT);
{вҐбвЁагҐв RightBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('RightBT :');
DisplayBT( RightBT( b ));writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
end{TRight};

procedure TCons( b :BinT);
{вҐбвЁагҐв ConsBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b
b - ­Ґ Їгбв®}
begin
write('BT=');
DisplayBT( b);writeln;
write('ConsBT (RootBT(b), LeftBT(b) ,RightBT(b) ) :');
DisplayBT( ConsBT( RootBT( b ), LeftBT( b ), RightBT( b ) ) );writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
end{TCons};

procedure TSetLeft( e:Char;var b :BinT);
{вҐбвЁагҐв SetLeft ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('SetLeft :');
SetLeft( e, b );
writeln;
write('BT=');
DisplayBT( b);writeln;
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,RightBT(b)); DestroyBT(Temp);
readkey;
end{TSetLeft};

procedure TSetRight( e:Char;var b :BinT);
{вҐбвЁагҐв SetRight ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
write('BT=');
DisplayBT( b);writeln;
write('SetRight :');
SetRight( e, b );
writeln;
write('BT=');
DisplayBT( b);writeln;
Temp:=RightBT(b); b:=ConsBT(RootBT( b ),LeftBT(b),NilBT); DestroyBT(Temp);
readkey;
end{TSetRight};

procedure TDisplay( b:BinT );
{вҐбвЁагҐв DisplayBT1 ­  ўе®¤­®¬ ¤ҐаҐўҐ b}
begin
writeln('DisplayBT :');
write(' ');DisplayBT( b);writeln;
writeln('DisplayBT1:');
DisplayBT1( b,1);
readkey;
end{TDisplay};
{---------------------------------------------------------------------------}

begin
Clrscr;
Assign(Fin,'intestbt.txt');
Reset(Fin);
b:=CreateBT;
{b:=EnterBT;}
OutBT( b ); Writeln;
Close(Fin);
{-----------------------NullBT---------------------------------------------}
Writeln( 'NullBT' );
Writeln(' ’Ґбв1 ');
b:=CreateBT;
TNull( b );
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TNull( b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TNull( b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TNull( b );
SetLeft('b',b);
Writeln(' ’Ґбв5 ');
TNull( b );
{---------------------------RootBT-----------------------------------------}
clrscr;
Writeln( 'RootBT' );
Writeln(' ’Ґбв1 ');
b:=CreateBT;
TRoot( b );
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TRoot( b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TRoot( b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TRoot( b );
SetLeft('b',b);
Writeln(' ’Ґбв5 ');
TRoot( b );
{----------------------------LeftBT-----------------------------------------}
clrscr;
Writeln( 'LeftBT' );
Writeln(' ’Ґбв1 ');
b:=CreateBT;
write('BT=');
DisplayBT( b);writeln;
write('LeftBT :'); LeftBT( b );
write('BT=');
DisplayBT( b );writeln;
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TLeft( b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TLeft( b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TLeft( b );
Writeln(' ’Ґбв5 ');
SetLeft('b',b);
TLeft( b );
{----------------------------RightBT----------------------------------------}
clrscr;
Writeln('RightBT');
Writeln(' ’Ґбв1 ');
b:=CreateBT;
write('BT=');
DisplayBT( b);writeln;
write('RightBT :'); RightBT( b );
write('BT=');
DisplayBT( b );writeln;
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TRight( b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TRight( b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TRight( b );
Writeln(' ’Ґбв5 ');
SetLeft('b',b);
TRight( b );
{----------------------------ConsBT-----------------------------------------}
clrscr;
Writeln('ConsBT');
Writeln(' ’Ґбв1 ');
b:=MakeRoot('a');
TCons( b );
Writeln(' ’Ґбв2 ');
SetLeft('b',b);
TCons( b );
Writeln(' ’Ґбв3 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TCons( b );
Writeln(' ’Ґбв4 ');
SetLeft('b',b);
TCons( b );
{---------------------------SetLeft----------------------------------------}
clrscr;
Writeln('SetLeft');
write('‚ўҐ¤ЁвҐ н«Ґ¬Ґ­в вЁЇ  Char:'); Readln(e);
Writeln(' ’Ґбв1 ');
b:=CreateBT;
write('BT=');
DisplayBT( b);writeln;
write('SetLeft :');
SetLeft( e, b );
writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TSetLeft( e, b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TSetLeft( e, b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TSetLeft( e, b );
Writeln(' ’Ґбв5 ');
SetLeft('b',b);
TSetLeft( e, b );
{---------------------------SetRight---------------------------------------}
clrscr;
Writeln('SetRight');
write('‚ўҐ¤ЁвҐ н«Ґ¬Ґ­в вЁЇ  Char:'); Readln(e);
Writeln(' ’Ґбв1 ');
b:=CreateBT;
write('BT=');
DisplayBT( b);writeln;
write('SetRight :');
SetRight( e, b );
writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TSetRight( e, b );
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TSetRight( e, b );
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
write('BT=');
DisplayBT( b);writeln;
write('SetRight :');
SetRight( e, b );
writeln;
write('BT=');
DisplayBT( b);writeln;
readkey;
Writeln(' ’Ґбв5 ');
SetLeft('b',b);
TSetRight( e, b );
{--------------------------DisplayBT1--------------------------------------}
clrscr;
Writeln('Display1BT');
Writeln(' ’Ґбв1 ');
b:=CreateBT;
TDisplay(b);
Writeln(' ’Ґбв2 ');
b:=MakeRoot('a');
TDisplay(b);
Writeln(' ’Ґбв3 ');
SetLeft('b',b);
TDisplay(b);
Writeln(' ’Ґбв4 ');
Temp:=LeftBT(b); b:=ConsBT(RootBT( b ),NilBT,MakeRoot('c')); DestroyBT(Temp);
TDisplay(b);
Writeln(' ’Ґбв5 ');
SetLeft('b',b);
TDisplay(b);
{--------------------------------------------------------------------------}
DestroyBT( b );
end.

============================================================================
TESTBT.CPP

#include"bintree.h"
#include<conio.h>

FILE *fin;

BinT EnterBT()
// ўў®¤ 㧫®ў ў Љ‹Џ-Ї®ап¤ЄҐ Ё Ї®бв஥­ЁҐ ЎЁ­ а­®Ј® ¤ҐаҐў 
{
Elem c;
if (fscanf ( fin,"%c", &c ))
{
if (c=='/') return 0;
else { BinT b1=EnterBT();
BinT b2=EnterBT();
return ConsBT ( c,b1 ,b2);
}
}
return 0;
}// EnterBT

void OutBT ( BinT b )
// ўлў®¤ 㧫®ў ЎЁ­ а­®Ј® ¤ҐаҐў  ў Љ‹Џ-Ї®ап¤ЄҐ
{
if ( !NullBT( b ) )
{
printf( "%c", RootBT ( b ) );
OutBT( LeftBT ( b ) );
OutBT( RightBT ( b ) );
}
else printf( "/" );
}// EnterBT

void DisplayBT ( BinT b, int n )
/* ўлў®¤ Ї®бва®з­®Ј® Ё Ї®ўҐа­гв®Ј® Ё§®Ўа ¦Ґ­Ёп ЎЁ­ а­®Ј® ¤ҐаҐў 
ЎҐ§ ў®§ўа в  Є®аҐвЄЁ
n - га®ўҐ­м 㧫  */
{
if ( !NullBT ( b ))
{
printf( " %c", RootBT( b ) );
if ( NullBT ( RightBT ( b ) ) )
printf("\n"); // ў­Ё§
else DisplayBT( RightBT ( b ), n+1);
if ( !NullBT ( LeftBT ( b ) ) )
{
for (int i=1;i<=n;i++) printf(" "); // ўЇа ў®
DisplayBT( LeftBT ( b ), n+1);
};
}
}// DisplayBT
//-------------Џа楤гал ЁбЇ®«м§гҐ¬лҐ ЇаЁ вҐбвЁа®ў ­ЁЁ-----------------------

void TNull ( BinT b )
//вҐбвЁагҐв NullBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
printf("NullBT : „ҐаҐў® ");
if ( !NullBT ( b ) ) printf(" ­Ґ ");
printf("Їгбв®.\n");
printf("BT=\n");
DisplayBT( b, 1);
getch();
}//TNull

void TRoot ( BinT b )
//вҐбвЁагҐв RootBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1 );
printf("\n");
printf("RootBT : %c",RootBT( b ));printf("\n");
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
getch();
}//TRoot

void TLeft( BinT b)
//вҐбвЁагҐв LeftBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
printf("LeftBT :");
DisplayBT( LeftBT( b ), 1);printf("\n");
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
getch();
}//TLeft

void TRight( BinT b)
//вҐбвЁагҐв RightBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
printf("RightBT :");
DisplayBT( RightBT( b ), 1); printf("\n");
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
getch();
}//TRight

void TCons( BinT b)
//вҐбвЁагҐв ConsBT ­  ўе®¤­®¬ ¤ҐаҐўҐ b (b - ­Ґ Їгбв®)
{
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
printf("ConsBT (RootBT(b), LeftBT(b) ,RightBT(b) ) :\n");
DisplayBT( ConsBT( RootBT( b ), LeftBT( b ), RightBT( b ) ), 1 );
printf("\nBT=\n");
DisplayBT( b, 1 ); printf("\n");
getch();
}//TCons

void TSetLeft( char e, BinT &b)
//вҐбвЁагҐв SetLeft ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
printf("SetLeft :");
SetLeft( e, b );
printf("\n");
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
BinT Temp=LeftBT(b); b=ConsBT(RootBT( b ), 0, RightBT(b)); DestroyBT(Temp);
getch();
}//TSetLeft

void TSetRight( char e, BinT &b )
//вҐбвЁагҐв SetRight ­  ўе®¤­®¬ ¤ҐаҐўҐ b
{
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
printf("SetRight :");
SetRight( e, b );
printf("\n");
printf("BT=\n");
DisplayBT( b, 1 ); printf("\n");
BinT Temp=RightBT(b); b=ConsBT(RootBT( b ),LeftBT(b), 0 );
DestroyBT(Temp);
getch();
}//TSetRight

void main()
{
fin=fopen("intestbt.txt", "r");
BinT b,Temp;
char e;
/* b=EnterBT();
DisplayBT ( b, 1 );
fclose ( fin );
OutBT( b ); printf("\n");
DestroyBT( b );
getch();*/
clrscr();
//-----------------------NullBT---------------------------------------------}
printf( "NullBT\n" );
printf(" ’Ґбв1 \n");
b=CreateBT();
TNull( b );
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TNull( b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TNull( b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0,MakeRoot('c')); DestroyBT(Temp);
TNull( b );
SetLeft('b',b);
printf(" ’Ґбв5 \n");
TNull( b );
//---------------------------RootBT-----------------------------------------
clrscr();
printf( "RootBT\n" );
printf(" ’Ґбв1 \n");
printf("BT=\n");
b=CreateBT();
DisplayBT( b, 1 );
printf("\n");
printf("RootBT :\n");
RootBT( b );
printf("\nBT=\n");
DisplayBT( b, 1 ); printf("\n");
getch();
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TRoot( b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TRoot( b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0,MakeRoot('c')); DestroyBT(Temp);
TRoot( b );
SetLeft('b',b);
printf(" ’Ґбв5 \n");
TRoot( b );
//----------------------------LeftBT-----------------------------------------}
clrscr();
printf( "LeftBT\n" );
printf(" ’Ґбв1 \n");
b=CreateBT();
TLeft( b );
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TLeft( b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TLeft( b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0,MakeRoot('c')); DestroyBT(Temp);
TLeft( b );
printf(" ’Ґбв5 \n");
SetLeft('b',b);
TLeft( b );
//----------------------------RightBT----------------------------------------}
clrscr();
printf("RightBT\n");
printf(" ’Ґбв1 \n");
b=CreateBT();
TRight( b );
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TRight( b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TRight( b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0 ,MakeRoot('c')); DestroyBT(Temp);
TRight( b );
printf(" ’Ґбв5 \n");
SetLeft('b',b);
TRight( b );
//----------------------------ConsBT-----------------------------------------}
clrscr();
printf("ConsBT\n");
printf(" ’Ґбв1 \n");
b=MakeRoot('a');
TCons( b );
printf(" ’Ґбв2 \n");
SetLeft('b',b);
TCons( b );
printf(" ’Ґбв3 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0 ,MakeRoot('c')); DestroyBT(Temp);
TCons( b );
printf(" ’Ґбв4 \n");
SetLeft('b',b);
TCons( b );
//---------------------------SetLeft----------------------------------------}
clrscr();
printf("SetLeft\n");
printf("‚ўҐ¤ЁвҐ н«Ґ¬Ґ­в вЁЇ  Char:"); cscanf("%c",&e);
printf("\n ’Ґбв1 \n");
b=CreateBT();
printf("BT=");
DisplayBT( b, 1); printf("\n");
printf("SetLeft :");
SetLeft( e, b );
printf("\n");
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
getch();
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TSetLeft( e, b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TSetLeft( e, b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0 ,MakeRoot('c')); DestroyBT(Temp);
TSetLeft( e, b );
printf(" ’Ґбв5 \n");
SetLeft('b',b);
TSetLeft( e, b );
//---------------------------SetRight---------------------------------------}
clrscr();
printf("SetRight\n");
printf("‚ўҐ¤ЁвҐ н«Ґ¬Ґ­в вЁЇ  Char:"); cscanf("%c",&e);
printf("\n ’Ґбв1 \n");
b=CreateBT();
printf("BT=");
DisplayBT( b, 1); printf("\n");
printf("SetRight :");
SetRight( e, b );
printf("\n");
printf("BT=\n");
DisplayBT( b, 1); printf("\n");
getch();
printf(" ’Ґбв2 \n");
b=MakeRoot('a');
TSetRight( e, b );
printf(" ’Ґбв3 \n");
SetLeft('b',b);
TSetRight( e, b );
printf(" ’Ґбв4 \n");
Temp=LeftBT(b); b=ConsBT(RootBT( b ),0,MakeRoot('c')); DestroyBT(Temp);
TSetRight( e, b );
printf(" ’Ґбв5 \n");
SetLeft('b',b);
TSetRight( e, b );
}
Соседние файлы в папке Бинарные деревья на языке Паскаль
Помощь Обратная связь Вопросы и предложения Пользовательское соглашение Политика конфиденциальности