Программирование и комп-ры

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


Казанский Государственный Технический Университет
                             им. А. Н. Туполева



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



                                       Выполнил: Зверев И. М.



                                       Проверил: Рахматуллин А. И.



                                   Казань
                                    2003
                                План работы:

   1) Постановка задачи
   2) Описание программы
   3) Код программы на языках Pascal и С++
                            1. Постановка задачи

       Требуется написать программу, реализующую основные операции работы с
деревом. Причём, обязательным условием является использование структуры
данных класс для описания дерева и методов работы с ним.
                            2. Описание программы

       Описание ведётся для кода на Pascalе, отличия для С++ будут указаны
ниже.
       В программе основным элементом является класс TTree. Его методы –
это основные процедуры работы с деревом:
       Create – конструктор класса – процедура, создающая дерево,
       Add – метод добавления элемента в дерево,
       Del – метод удаления элемента из дерева,
       View – метод вывода элементов дерева на экран,
       Exist – метод проверки существования элемента с некоторым ключом, по
сути поиск элемента,
       Destroy – деструктор класса – процедура, удаляющая дерево.

       Рассмотрим алгоритмы работы процедур.

       Create – создание дерева. Присваивает полю  Root  (корень)  значение
nil – указателя, который никуда не указывает.

       Add – добавление элемента в дерево. Для построения дерева используем
следующий  алгоритм.  Первый  элемент  помещаем  в  корень   (инициализируем
дерево). Далее  поступаем  следующим  образом.  Если  добавляемый  в  дерево
элемент имеет ключ больший, чем ключ узла, то, если узел  не  лист,  обходим
его справа. Если добавляемый элемент имеет ключ не больший  чем  ключ  узла,
то, если узел не лист, обходим его слева. Если дошли до листа, то  добавляем
элемент соответственно справа или слева.

       Del – удаление элемента из дерева.
       Удаление узла довольно просто если  он  является  листом  или  имеет
одного потомка. Например, если  требуется  удалить  узел  с  ключом  М  надо
просто  заменить  правую  ссылку  узла  К  на  указатель  на  L.   Трудность
заключается в удалении  узла  с  двумя  потомками,  поскольку  мы  не  можем
указать одним указателем на два направления.
                                    [pic]
       [pic]Например, если  просто  удалить  узел  с  ключом  N,  то  левый
указатель узла с ключом Т должен указывать одновременно на  К  и  R  что  не
возможно. В этом случае удаляемый узел нужно  заменить  на  другой  узел  из
дерева. Возникает вопрос, каким же узлом  его  заменить?  Этот  узел  должен
обладать двумя свойствами:  во-первых,  он  должен  иметь  не  более  одного
потомка; во-вторых, для сохранения упорядоченности ключей, он  должен  иметь
ключ либо не меньший, чем любой ключ левого поддерева удаляемого узла,  либо
не  больший,  чем  любой  ключ  правого  поддерева  удаляемого  узла.  Таким
свойствам обладают два узла, самый правый узел левого  поддерева  удаляемого
узла и самый левый узел его правого поддерева. Любым из этих узлов им  можно
заменить удаляемый узел. Например, на рисунке это узлы М и Р.
       [pic]Необходимо различать три случая:
   1. Узла с ключем, равным х, нет.
   2. Узел с ключем, равным х, имеет не более одного потомка.
   3. Узел с ключем, равным х, имеет двух потомков
       Вспомогательная  рекурсивная  процедура  del  вызывается  только   в
случае, когда удаляемый узел имеет двух  потомков.  Она  “спускается  вдоль”
самой  правой  ветви  левого  поддерева  удаляемого  узла  q^  (при   вызове
процедуры ей передается в качестве параметра указатель на  левое  поддерево)
и, затем, заменяет существенную информацию (в нашем случае ключ data)  в  q^
соответствующим значением самого правого узла  r^  этого  левого  поддерева,
после чего от r^ можно освободиться.

       View - печать дерева, обходя его справа налево. Чем  дальше  элемент
от корня,  тем  больше  ему  будет  предшествовать  пробелов,  т.  о.  путём
несложного алгоритма получается вполне удобно читаемое дерево.

       Exist – проверка существования  элемента  с  заданным  ключом.  Ищем
элемент, двигаясь от корня и переходя на левое или правое поддерево  каждого
узла в зависимости от его ключа.

       Destroy – удаление дерева.  Обходя  дерево  слева  направо,  удаляет
элементы. Сначала удаляются потомки узла, затем сам узел.

       Различия  между  описаниями  кодов  программах  на   разных   языках
относятся в основном к конструкторам и деструкторам. В .pas  программах  они
определяются директивами и вызываются явно как методы класса  из  программы,
а в .cpp конструктор вызывается при создании элемента  класса  и  деструктор
автоматически при выходе из программы (для чего объект класса размещается  в
памяти динамически).

                              3. Код программы

|program PTree;                      |#include                |
|                                    |                                    |
|{$APPTYPE CONSOLE}                  |#pragma hdrstop                     |
|                                    |                                    |
|type                                |typedef int TInfo;                  |
|TInfo = Byte;                       |typedef struct Item* PItem;         |
|PItem = ^Item;                      |struct Item {                       |
|Item = record                       |TInfo Key;                          |
|Key: TInfo;                         |PItem Left, Right;                  |
|Left, Right: PItem;                 |};                                  |
|end;                                |class TTree {                       |
|TTree = class                       |private:                            |
|private                             |PItem Root;                         |
|Root: PItem;                        |public:                             |
|public                              |TTree();                            |
|constructor Create;                 |void Add(TInfo Key);                |
|procedure Add(Key: TInfo);          |void Del(TInfo Key);                |
|procedure Del(Key: TInfo);          |void View();                        |
|procedure View;                     |void Exist(TInfo Key);              |
|procedure Exist(Key: TInfo);        |~TTree();                           |
|destructor Destroy; override;       |};                                  |
|end;                                |                                    |
|//----------------------------------|//----------------------------------|
|---------------------------         |---------------------------         |
|constructor TTree.Create;           |TTree::TTree()                      |
|begin                               |{                                   |
|Root := nil;                        |Root = NULL;                        |
|end;                                |}                                   |
|//----------------------------------|//----------------------------------|
|---------------------------         |---------------------------         |
|procedure TTree.Add(Key: TInfo);    |static void IniTree(PItem& P, TInfo |
|                                    |X) //создание корня дерева          |
|procedure IniTree(var P: PItem; X:  |{                                   |
|TInfo); //создание корня дерева     |P = new Item;                       |
|begin                               |P->Key =X;                          |
|New(P);                             |P->Left = NULL;                     |
|P^.Key :=X;                         |P->Right = NULL;                    |
|P^.Left := nil;                     |}                                   |
|P^.Right := nil;                    |                                    |
|end;                                |static void Iendleft (PItem& P,     |
|                                    |TInfo X) //добавление узла слева    |
|procedure InLeft (var P: PItem; X : |{                                   |
|TInfo); //добавление узла слева     |PItem R;                            |
|var R : PItem;                      |                                    |
|begin                               |R = new Item;                       |
|New(R);                             |R->Key = X;                         |
|R^.Key := X;                        |R->Left = NULL;                     |
|R^.Left := nil;                     |R->Right = NULL;                    |
|R^.Right := nil;                    |P->Left = R;                        |
|P^.Left := R;                       |}                                   |
|end;                                |                                    |
|                                    |static void InRight (PItem& P, TInfo|
|procedure InRight (var P: PItem; X :|X) //добавить узел справа           |
|TInfo); //добавить узел справа      |{                                   |
|var R : PItem;                      |PItem R;                            |
|begin                               |                                    |
|New(R);                             |R = new Item;                       |
|R^.Key := X;                        |R->Key = X;                         |
|R^.Left := nil;                     |R->Left = NULL;                     |
|R^.Right := nil;                    |R->Right = NULL;                    |
|P^.Right := R;                      |P->Right = R;                       |
|end;                                |}                                   |
|                                    |                                    |
|procedure Tree_Add (P: PItem; X :   |static void Tree_Add (PItem P, TInfo|
|TInfo);                             |X)                                  |
|var OK: Boolean;                    |{                                   |
|begin                               |int OK;                             |
|OK := false;                        |OK = false;                         |
|while not OK do begin               |while (! OK)  {                     |
|if X > P^.Key then //посмотреть     |if (X > P->Key)  //посмотреть       |
|направо                             |направо                             |
|if P^.Right <> nil //правый узел не |if (P->Right != NULL) //правый узел |
|nil                                 |не NULL                             |
|then P := P^.Right //обход справа   |P = P->Right; //обход справа        |
|else begin //правый узел - лист и   |else { //правый узел - лист и надо  |
|надо добавить к нему элемент        |добавить к нему элемент             |
|InRight (P, X); //и конец           |InRight (P, X); //и конец           |
|OK := true;                         |OK = true;                          |
|end                                 |}                                   |
|else //посмотреть налево            |else //посмотреть налево            |
|if P^.Left <> nil //левый узел не   |if (P->Left != NULL) //левый узел не|
|nil                                 |NULL                                |
|then P := P^.Left //обход слева     |P = P->Left; //обход слева          |
|else begin //левый узел -лист и надо|else { //левый узел -лист и надо    |
|добавить к нему элемент             |добавить к нему элемент             |
|InLeft(P, X); //и конец             |Iendleft(P, X); //и конец           |
|OK := true                          |OK = true;                          |
|end;                                |}                                   |
|end; //цикла while                  |} //цикла while                     |
|end;                                |}                                   |
|                                    |                                    |
|begin                               |void TTree::Add(TInfo Key)          |
|if Root = nil                       |                                    |
|then IniTree(Root, Key)             |{                                   |
|else Tree_Add(Root, Key);           |if (Root == NULL)                   |
|end;                                |IniTree(Root, Key);                 |
|//----------------------------------|else Tree_Add(Root, Key);           |
|---------------------------         |}                                   |
|procedure TTree.Del(Key: TInfo);    |//----------------------------------|
|                                    |---------------------------static   |
|procedure Delete (var P: PItem; X:  |void delete_ (PItem& P, TInfo X);   |
|TInfo);                             |                                    |
|var Q: PItem;                       |static void Del(PItem& R, PItem& Q) |
|                                    |//процедура удаляет узел имеющий    |
|procedure Del(var R: PItem);        |двух потомков, заменяя его на самый |
|//процедура удаляет узел имеющий    |правый                              |
|двух потомков, заменяя его на самый |//узел левого поддерева             |
|правый                              |{                                   |
|//узел левого поддерева             |if (R->Right != NULL)  //обойти     |
|begin                               |дерево справа                       |
|if R^.Right <> nil then //обойти    |Del(R->Right, Q);                   |
|дерево справа                       |else {                              |
|Del(R^.Right)                       |//дошли до самого правого узла      |
|else begin                          |//заменить этим узлом удаляемый     |
|//дошли до самого правого узла      |Q->Key = R->Key;                    |
|//заменить этим узлом удаляемый     |Q = R;                              |
|                                    |R = R->Left;                        |
|Q^.Key := R^.Key;                   |}                                   |
|Q := R;                             |} //Del                             |
|R := R^.Left;                       |                                    |
|end;                                |static void delete_ (PItem& P, TInfo|
|end; //Del                          |X)                                  |
|                                    |{                                   |
|begin //Delete                      |PItem Q;                            |
|if P <> nil then //искать удаляемый |//Delete                            |
|узел                                |if (P != NULL)  //искать удаляемый  |
|if X < P^.Key then                  |узел                                |
|Delete(P^.Left, X)                  |if (X < P->Key)                     |
|else                                |delete_(P->Left, X);                |
|if X > P^.Key then                  |else                                |
|Delete(P^.Right, X) //искать в      |if (X > P->Key)                     |
|правом поддереве                    |delete_(P->Right, X); //искать в    |
|else begin                          |правом поддереве                    |
|//узел найден, надо его удалить     |                                    |
|//сохранить ссылку на удаленный узел|else {                              |
|                                    |//узел найден, надо его удалить     |
|Q := P;                             |//сохранить ссылку на удаленный узел|
|if Q^.Right = nil then              |                                    |
|//справа nil                        |Q = P;                              |
|//и ссылку на узел надо заменить    |if (Q->Right == NULL)               |
|ссылкой на этого потомка            |//справа NULL                       |
|P := Q^.Left                        |//и ссылку на узел надо заменить    |
|else                                |ссылкой на этого потомка            |
|if Q^.Left = nil then               |P = Q->Left;                        |
|//слева nil                         |else                                |
|//и ссылку на узел надо заменить    |if (Q->Left == NULL)                |
|ссылкой на этого потомка            |//слева NULL                        |
|P := P^.Right                       |//и ссылку на узел надо заменить    |
|else //узел имеет двух потомков     |ссылкой на этого потомка            |
|Del(Q^.Left);                       |P = P->Right;                       |
|Dispose(Q);                         |else //узел имеет двух потомков     |
|end                                 |Del(Q->Left, Q);                    |
|else                                |delete Q;                           |
|WriteLn('Такого элемента в дереве   |}                                   |
|нет');                              |else                                |
|end;                                |cout << "Такого элемента в дереве   |
|                                    |нет" << endl;                       |
|begin                               |}                                   |
|Delete(Root, Key);                  |                                    |
|end;                                |void TTree::Del(TInfo Key)          |
|//----------------------------------|                                    |
|---------------------------         |{                                   |
|procedure TTree.View;               |delete_(Root, Key);                 |
|                                    |}                                   |
|procedure PrintTree(R: PItem; L:    |//----------------------------------|
|Byte);                              |---------------------------         |
|var i: Byte;                        |static void PrintTree(PItem R, TInfo|
|begin                               |L)                                  |
|if R <> nil then begin              |{                                   |
|PrintTree(R^.Right, L + 3);         |int i;                              |
|for i := 1 to L do                  |                                    |
|Write(' ');                         |if (R != NULL)  {                   |
|WriteLn(R^.Key);                    |PrintTree(R->Right, L + 3);         |
|PrintTree(R^.Left, L + 3);          |for( i = 1; i <= L; i ++)           |
|end;                                |cout << ' ';                        |
|end;                                |cout << R->Key << endl;             |
|                                    |PrintTree(R->Left, L + 3);          |
|begin                               |}                                   |
|PrintTree (Root, 1);                |}                                   |
|end;                                |                                    |
|//----------------------------------|void TTree::View()                  |
|---------------------------         |{                                   |
|procedure TTree.Exist(Key: TInfo);  |PrintTree (Root, 1);                |
|                                    |}                                   |
|procedure Search(var P: PItem; X:   |//----------------------------------|
|TInfo);                             |---------------------------         |
|begin                               |static void Search(PItem& P, TInfo  |
|if P = nil then begin               |X)                                  |
|WriteLn('Такого элемента нет');     |{                                   |
|end else                            |if (P == NULL)  {                   |
|if X > P^. Key then //ищется в      |cout << "Такого элемента нет" <<    |
|правом поддереве                    |endl;                               |
|Search (P^. Right, X)               |} else                              |
|else                                |if (X > P-> Key)  //ищется в правом |
|if X < P^. Key then                 |поддереве                           |
|Search (P^. Left, X)                |Search (P-> Right, X);              |
|else                                |else                                |
|WriteLn('Есть такой элемент');      |if (X < P-> Key)                    |
|end;                                |Search (P-> Left, X);               |
|                                    |else                                |
|begin                               |cout << "Есть такой элемент" <<     |
|Search(Root, Key);                  |endl;                               |
|end;                                |}                                   |
|//----------------------------------|                                    |
|---------------------------         |void TTree::Exist(TInfo Key)        |
|destructor TTree.Destroy;           |                                    |
|                                    |{                                   |
|procedure Node_Dispose(P: PItem);   |Search(Root, Key);                  |
|//Удаление узла и всех его потомков |}                                   |
|в дереве                            |//----------------------------------|
|begin                               |---------------------------         |
|if P <> nil then begin              |static void Node_Dispose(PItem P)   |
|if P^.Left <> nil then              |//Удаление узла и всех его потомков |
|Node_Dispose (P^.Left);             |в дереве                            |
|if P^.Right <> nil then             |{                                   |
|Node_Dispose (P^.Right);            |if (P != NULL)  {                   |
|Dispose(P);                         |if (P->Left != NULL)                |
|end;                                |Node_Dispose (P->Left);             |
|end;                                |if (P->Right != NULL)               |
|                                    |Node_Dispose (P->Right);            |
|begin                               |delete P;                           |
|Node_Dispose(Root);                 |}                                   |
|end;                                |}                                   |
|//----------------------------------|                                    |
|---------------------------         |TTree::~TTree()                     |
|procedure InputKey(S: String; var   |                                    |
|Key: TInfo);                        |{                                   |
|begin                               |Node_Dispose(Root);                 |
|WriteLn(S);                         |}                                   |
|ReadLn(Key);                        |//----------------------------------|
|end;                                |---------------------------         |
|                                    |void inputKey(string S, TInfo& Key) |
|var                                 |{                                   |
|Tree: TTree;                        |cout << S << endl;                  |
|N: Byte;                            |cin >> Key;                         |
|Key: TInfo;                         |}                                   |
|begin                               |                                    |
|Tree := TTree.Create;               |TTree *Tree = new TTree;            |
|repeat                              |int N;                              |
|WriteLn('1-Добавить элемент в       |TInfo Key;                          |
|дерево');                           |int main(int argc, const char*      |
|WriteLn('2-Удалить элемент');       |argv[])                             |
|WriteLn('3-Вывести узлы дерева');   |{                                   |
|WriteLn('4-Проверить существование  |do {                                |
|узла');                             |cout << "1-Добавить элемент в       |
|WriteLn('5-Выход');                 |дерево" << endl;                    |
|ReadLn(n);                          |cout << "2-Удалить элемент" << endl;|
|with Tree do begin                  |                                    |
|case N of                           |cout << "3-Вывести узлы дерева" <<  |
|1: begin                            |endl;                               |
|InputKey('Введите значение          |cout << "4-Проверить существование  |
|добавляемого элемента', Key);       |узла" << endl;                      |
|Add(Key);                           |cout << "5-Выход" << endl;          |
|end;                                |cin >> N;                           |
|2: begin                            |{                                   |
|InputKey('Введите значение          |switch (N) {                        |
|удаляемого элемента', Key);         |case 1: {                           |
|Del(Key);                           |inputKey("Введите значение          |
|end;                                |добавляемого элемента", Key);       |
|3: View;                            |Tree->Add(Key);                     |
|4: begin                            |}                                   |
|InputKey('Введите элемент,          |break;                              |
|существование которого вы хотите    |case 2: {                           |
|проверить', Key);                   |inputKey("Введите значение          |
|Exist(Key);                         |удаляемого элемента", Key);         |
|end;                                |Tree->Del(Key);                     |
|end;                                |}                                   |
|end;                                |break;                              |
|until N=5;                          |case 3: Tree->View(); break;        |
|Tree.Destroy;                       |case 4: {                           |
|end.                                |inputKey("Введите элемент,          |
|                                    |существование которого вы хотите    |
|                                    |проверить", Key);                   |
|                                    |Tree->Exist(Key);                   |
|                                    |}                                   |
|                                    |break;                              |
|                                    |}                                   |
|                                    |}                                   |
|                                    |} while (!(N==5));                  |
|                                    |return EXIT_SUCCESS;                |
|                                    |}                                   |



смотреть на рефераты похожие на "Структуры данных: бинарное упорядоченное несбалансированное дерево "