СПИСОК
pList.c
// Реалізація інтерфейсу обробки списків
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "plist.h"
// Ініціалізація списку
void Init(list *head_list_ptr)
{
*head_list_ptr = NULL;
return;
}
// Перевірка чи список порожній
int Empty(list head_list)
{
return head_list == NULL;
}
// Додавання нового вузла на початок списку
void AddStart(list *head_list_ptr, infotype new_data)
{
list new_node;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = *head_list_ptr;
*head_list_ptr = new_node;
return ;
}
// Додавання нового вузла в кінець списку
void AddEnd(list *head_list_ptr, infotype new_data)
{
list new_node;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = NULL;
if (Empty(*head_list_ptr)) *head_list_ptr = new_node;
else
FindLast(*head_list_ptr)->next = new_node;
return ;
}
// Вставка нового вузла після заданого вузла списку
void PutAfter(list *node_prt, infotype new_data)
{
list new_node = NULL;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = (*node_prt)->next;
(*node_prt)->next = new_node;
return ;
}
// Вставка нового вузла перед заданим вузлом списку
void PutBefore(list *node_prt, infotype new_data)
{
PutAfter(node_prt,new_data);
Change(node_prt,&((*node_prt)->next));
return ;
}
// Обмін інформаційних полів двух заданих вузлів списку
void Change(list *node1_ptr, list *node2_ptr)
{
infotype tmp = (*node1_ptr)->data;
(*node1_ptr)->data = (*node2_ptr)->data;
(*node2_ptr)->data = tmp;
}
// Пошук вузла із заданим значенням в списку
list Find(list head_list, infotype search_data)
{
while ((head_list) && (head_list->data != search_data)) head_list = head_list->next;
return head_list;
}
// Пошук вузла в списку, що знаходиться перед заданим вузлом
list FindBefore(list head_list, list node)
{
while ((head_list->next != node) && head_list) head_list = head_list->next;
return head_list;
}
// Пошук вузла в списку що знаходиться після заданого вузла
list FindAfter(list node)
{
return node->next;
}
// Пошук останнього вузла списку
list FindLast(list head_list)
{
if (head_list) while (head_list->next) head_list = head_list->next;
return head_list;
}
// Вилучення заданого вузла зі списку
void Delete(list *head_list_ptr, list *node_ptr)
{
list tmp , save_ptr=*node_ptr;
assert(*head_list_ptr);
assert(*node_ptr);
if (*node_ptr == *head_list_ptr)
*head_list_ptr = (*head_list_ptr)->next;
else
if (!((*node_ptr)->next))
{
tmp = FindBefore(*head_list_ptr,*node_ptr);
tmp->next = NULL;
}
else
{
tmp = (*node_ptr)->next;
(*node_ptr)->data = tmp->data;
(*node_ptr)->next = tmp->next;
save_ptr = tmp;
};
free(save_ptr);
return ;
}
// Роздрук списку в прямому порядку
void PrintStraight(list head_list)
{
while (head_list)
{
printf(printfspec,head_list->data);
head_list = head_list->next;
}
printf("\n");
return;
}
// Роздрук списку в зворотньому порядку
void PrintReverse(list head_list)
{
if (head_list)
{
PrintReverse(head_list->next);
printf(printfspec,head_list->data);
}
return;
}
/----------------------------------------------------------------------------------/
pList.h
// Інтерфейс обробки списків
#define infotype int
#define printfspec "%d "
/*
Нагадую символи форматування для основних типів даних:
----------------+-----------------------------
| %c | char |
|---------------+----------------------------|
| %d | int, short |
|---------------+----------------------------|
| %ld | long |
|---------------+----------------------------|
| %f | float, double |
|---------------+----------------------------|
| %s | arrays of type of char |
|---------------+----------------------------|
| %u | unsigned int,unsigned short|
|---------------+----------------------------|
| %lu | unsigned long |
----------------+-----------------------------
*/
struct node
{ infotype data;
struct node *next;
};
typedef struct node *list;
void Init(list *head_list_ptr);
int Empty(list head_list);
void AddStart(list *head_list_ptr, infotype new_data);
void AddEnd(list *head_list_ptr, infotype new_data);
void PutAfter(list *node_prt, infotype new_data);
void PutBefore(list *node_prt, infotype new_data);
void Change(list *node1_ptr, list *node2_ptr);
list Find(list head_list, infotype search_data);
list FindBefore(list head_list, list node_ptr);
list FindAfter(list node_ptr);
list FindLast(list head_list);
void Delete(list *head_list_ptr, list *node_ptr);
void PrintStraight(list head_list);
void PrintReverse(list head_list);
/----------------------------------------------------------------------------------/
testlist.c
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "plist.h"
list MergeLists(list list1, list list2);
void main()
{
list l2 , fl;
infotype x = 0;
struct node a={3,NULL}, b={2,&a}, c={1,&b}, *l1 = &c;
Init(&l2);
printf("\nEnter elements in the second list:\n");
do {
printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&x);
if (x!=0)
AddEnd(&l2,x);
}
while (x);
PrintStraight(l1);
PrintStraight(l2);
PutBefore(&(l1->next),4); PrintStraight(l1);
AddStart(&l1,6); PrintStraight(l1);
AddEnd(&l1,5); PrintStraight(l1);
Delete(&l1,&l1); PrintStraight(l1);
fl = Find(l1,4);
Delete(&l1,&fl); PrintStraight(l1);
Change(&l1,&(l1->next)); PrintStraight(l1);
printf("\nMerged lists:\n");
PrintStraight(MergeLists(l1,l2));
printf("\nPrinted merged lists in back order:\n");
PrintReverse(MergeLists(l1,l2));
getch();
return;
}
list MergeLists(list list1, list list2)
{
list mlist = NULL;
while (list1)
{
AddEnd(&mlist,list1->data);
list1 = list1->next;
};
while (list2 )
{
AddEnd(&mlist,list2->data);
list2 = list2->next;
};
return mlist;
}
Стек
astack.c
// Реалізація інтерфейсу обробки стеку
#include <stdio.h>
#include "astack.h"
// Ініціалізація стеку
void Init(stack *s)
{ (*s).top = -1;
return;}
// Перевірка чи стек порожній
int Empty(stack s)
{ return s.top == -1;}
// Перевірка чи стек повний
int Full(stack s)
{ return s.top == size;}
// Додавання в стек
void Push(stack *s, infotype new_data)
{ if (Full(*s))
printf(" Error : Stack overflowed! \n");
else
(*s).data[++(*s).top] = new_data;
return;}
// Вилучення зі стеку
infotype Pop(stack *s)
{ if (Empty(*s))
{ printf(" Error : Stack is empty! \n");
return 0;
}
else
return (*s).data[(*s).top--];}
// Роздрук стеку
void Print(stack s)
{ int i;
printf("Elements of stack: ");
if (Empty(s))
printf("Stack is empty! \n");
else
{ for (i=0;i<=s.top;i++) printf(printfspec,s.data[i]);
printf("\n");
}
return;}
/----------------------------------------------------------------------------------/
astack.h
// Інтерфейс обробки стеку
#define size 100
#define infotype int
#define printfspec "%d "
struct stacktype
{ infotype data[size];
int top;
} ;
typedef struct stacktype stack;
void Init(stack *s);
int Empty(stack s);
int Full(stack s);
void Push(stack *s, infotype new_data);
infotype Pop(stack *s);
void Print(stack s);
/----------------------------------------------------------------------------------/
testastack.c
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "astack.h"
void main()
{ stack ST;
infotype x;
Init(&ST);
printf("\nEnter elements in the stack:\n");
do
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&x);
if (x)
Push(&ST,x); }
while (x);
Print(ST);
x=Pop(&ST);
Print(ST);
Pop(&ST);
Print(ST);
Pop(&ST);
Print(ST);
Push(&ST,x);
Print(ST);
getch();
return;}
/----------------------------------------------------------------------------------/
pstack.c
// Реалізація інтерфейсу обробки стеку
#include <stdio.h>
#include <stdlib.h>
#include "pstack.h"
// Ініціалізація стеку
void Init(stack *stack_top_ptr)
{ *stack_top_ptr = NULL;
return;}
// Перевірка чи стек порожній
int Empty(stack stack_top)
{ return stack_top == NULL;}
// Додавання в стек
void Push(stack *stack_top_ptr, infotype new_data)
{ stack new_node;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = *stack_top_ptr;
*stack_top_ptr = new_node;
return;}
// Вилучення зі стеку
infotype Pop(stack *stack_top_ptr)
{ stack del_node;
infotype del_data;
if (Empty(*stack_top_ptr))
{ printf(" Error : Stack is empty!\n");
return 0; }
else
{ del_node = *stack_top_ptr;
del_data = (*stack_top_ptr)->data;
*stack_top_ptr = (*stack_top_ptr)->next;
free(del_node);
return del_data;
};}
// Роздрук стеку
void Print(stack stack_top)
{ void PrintReverse(stack stack_top);
printf("Elements of stack: ");
if (Empty(stack_top))
printf("Stack is empty! \n");
else
{ PrintReverse(stack_top);
printf("\n");
}
return;}
void PrintReverse(stack stack_top)
{
if (stack_top)
{
PrintReverse(stack_top->next);
printf(printfspec,stack_top->data);
}
return;}
/----------------------------------------------------------------------------------/
pstack.h
// Інтерфейс обробки стеку
#define infotype int
#define printfspec "%d "
struct node
{ infotype data;
struct node *next;
} ;
typedef struct node *stack;
void Init(stack *stack_top_ptr);
int Empty(stack stack_top);
void Push(stack *stack_top_ptr, infotype new_data);
infotype Pop(stack *stack_top_ptr);
void Print(stack stack_top);
testpstack.c
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "pstack.h"
void main()
{ stack ST;
infotype x;
Init(&ST);
printf("\nEnter elements in the stack:\n");
do
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&x);
if (x)
Push(&ST,x);
}
while (x);
Print(ST);
x=Pop(&ST);
Print(ST);
Pop(&ST);
Print(ST);
Pop(&ST);
Print(ST);
Push(&ST,x);
Print(ST);
getch();
return;
}
Черга
aqueue.c
// Реалізація інтерфейсу обробки черги
#include <stdio.h>
#include "aqueue.h"
// Ініціалізація черги
void Init(queue *q)
{ (*q).tale = -1;
(*q).head = 0;
return;}
// Перевірка чи черга порожня
int Empty(queue q)
{ return q.tale+1 == q.head;}
// Перевірка чи черга повна
int Full(queue q)
{ return ((q.head == 0) && (q.tale == size-1));}
// Додавання в чергу
void Insert(queue *q, infotype new_data)
{ if (Full(*q))
printf(" Error : Queue overflow ! \n");
else
(*q).data[++(*q).tale] = new_data;
return;}
// Вилучення з черги
infotype Remove(queue *q)
{ if (Empty(*q))
{ printf(" Error : Queue underflow ! \n");
return 0; }
else
return (*q).data[(*q).head++];}
// Роздрук черги
void Print(queue q)
{ int i;
printf("Elements of queue: ");
if (Empty(q))
printf("Queue is empty ! \n");
else
{ for (i=q.head;i<=q.tale;i++) printf(printfspec,q.data[i]);
printf("\n"); }
return;}
/----------------------------------------------------------------------------------/
aqueue.h
// Інтерфейс обробки черги
#define size 100
#define infotype int
#define printfspec "%d "
struct queuetype
{ infotype data[size];
int head , tale;} ;
typedef struct queuetype queue;
void Init(queue *q);
int Empty(queue q);
int Full(queue q);
void Insert(queue *q, infotype new_data);
infotype Remove(queue *q);
void Print(queue q);
/----------------------------------------------------------------------------------/
testaqueue.c
#include <stdio.h>
#include <conio.h>
#include "aqueue.h"
void main()
{ queue Q1;
queue *Q2;
infotype x , y;
Init(&Q1);
printf("\nEnter elements in the queue:\n");
do
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&x);
if (x)
Insert(&Q1,x); }
while (x);
Print(Q1);
x=Remove(&Q1);
Print(Q1);
Remove(&Q1);
Print(Q1);
Remove(&Q1);
Print(Q1);
Insert(&Q1,x);
Print(Q1);
//other:
Q2 = malloc(sizeof(queue));
Init(Q2);
printf("\nEnter elements in the gueue:\n");
for (;y!=0;)
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&y);
if (y)
Insert(Q2,y); }
Print(*Q2);
x=Remove(Q2);
Print(*Q2);
Remove(Q2);
Print(*Q2);
Remove(Q2);
Print(*Q2);
Insert(Q2,x);
Print(*Q2);
free(Q2);
getch();
return;}
/----------------------------------------------------------------------------------/
pqueue.c
// Реалізація інтерфейсу обробки черги
#include <stdio.h>
#include <stdlib.h>
#include "pqueue.h"
// Ініціалізація черги
void Init(queue *queue_union_ptr)
{ (*queue_union_ptr).tail = NULL;
(*queue_union_ptr).head = NULL;
return;}
// Перевірка чи черга порожня
int Empty(queue queue_union)
{ return queue_union.head == NULL;}
// Додавання в чергу
void Insert(queue *queue_union_ptr, infotype new_data)
{ struct node *new_node;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = NULL;
if (Empty(*queue_union_ptr))
{ (*queue_union_ptr).head = ((*queue_union_ptr).tail = new_node);
return; }
(*queue_union_ptr).tail->next = new_node;
(*queue_union_ptr).tail = new_node;
return;}
// Вилучення з черги
infotype Remove(queue *queue_union_ptr)
{ struct node *del_node;
infotype del_data;
if (Empty(*queue_union_ptr))
{ printf(" Error : Queue underflow ! \n");
return 0; }
else
{ del_node = (*queue_union_ptr).head;
del_data = (*queue_union_ptr).head->data;
(*queue_union_ptr).head = (*queue_union_ptr).head->next;
if (Empty(*queue_union_ptr))
(*queue_union_ptr).tail = NULL;
free(del_node);
return del_data;
};}
// Роздрук черги
void Print(queue queue_union)
{ struct node *tmp;
printf("Elements of queue: ");
if (Empty(queue_union))
printf("Queue is empty ! \n");
else
{ tmp = queue_union.head;
while (tmp)
{ printf(printfspec, tmp->data);
tmp = tmp->next;
};
printf("\n");
}
return;}
/----------------------------------------------------------------------------------/
pqueue.h
// Інтерфейс обробки черги

#define infotype int
#define printfspec "%d "
struct node1
{ infotype data;
struct node1 *next;
};
struct queuetype
{ struct node *head, *tail;
};
typedef struct queuetype queue;
void Init(queue *queue_union_ptr);
int Empty(queue queue_union);
void Insert(queue *queue_union_ptr, infotype new_data);
infotype Remove(queue *queue_union_ptr);
void Print(queue queue_union);
/----------------------------------------------------------------------------------/
testpqueue.c
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#include "pqueue.h"
void main()
{ queue Q1;
queue *Q2;
infotype x , y;
Init(&Q1);
printf("\nEnter elements in the queue:\n");
do
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&x);
if (x)
Insert(&Q1,x);
}
while (x);
Print(Q1);
x=Remove(&Q1);
Print(Q1);
Remove(&Q1);
Print(Q1);
Remove(&Q1);
Print(Q1);
Insert(&Q1,x);
Print(Q1);
//other:
Q2 = malloc(sizeof(queue));
Init(Q2);
printf("\nEnter elements in the queue:\n");
for (;y!=0;)
{ printf("Enter the new element(zero - break inputing elements): ");
scanf("%d",&y);
if (y)
Insert(Q2,y);
}
Print(*Q2);
x=Remove(Q2);
Print(*Q2);
Remove(Q2);
Print(*Q2);
Remove(Q2);
Print(*Q2);
Insert(Q2,x);
Print(*Q2);
free(Q2);
getch();
return;
}
Дерева
pBTREE.c
// Реалізація інтерфейсу обробки бінарного дерева (БД) пошуку
#include <stdio.h>
#include <stdlib.h>
#include "pbtree.h"
// Ініціалізація БД
void Init(binary_tree *root_ptr)
{ *root_ptr = NULL;}
// Перевірка чи БД порожнє
int Empty(binary_tree root)
{
return root == NULL;}
// Пошук лівого сина заданого вузла БД
binary_tree WhoLeft(binary_tree tree_node)
{
if (tree_node)
return tree_node->leftson;
else
return tree_node;}
// Пошук правого сина заданого вузла БД
binary_tree WhoRight(binary_tree tree_node)
{
if (tree_node)
return tree_node->rightson;
else
return tree_node;
}
// Створення нового вузла БД із заданим значенням
binary_tree MakeNode(infotype new_data)
{
binary_tree new_node;
new_node = malloc(sizeof(struct node));
new_node->data = new_data;
new_node->leftson = new_node->rightson = NULL;
return new_node;}
// Створення лівого сина заданого вузла БД
void PutLeft(binary_tree tree_node, infotype new_data)
{
binary_tree new_node;
new_node = MakeNode(new_data);
tree_node->leftson = new_node;}
// Створення правого сина заданого вузла БД
void PutRight(binary_tree tree_node, infotype new_data)
{
binary_tree new_node;
new_node = MakeNode(new_data);
tree_node->rightson = new_node;}
// Допоміжна функція для функції Find
void F(binary_tree root, infotype search_data, binary_tree *search_node_ptr)
{
if (root && !*search_node_ptr)
if (root->data == search_data)
*search_node_ptr = root;
else
{
F(WhoLeft(root), search_data, search_node_ptr);
F(WhoRight(root), search_data, search_node_ptr);
};}
// Пошук у БД першого вузла із заданим значенням
binary_tree Find(binary_tree root, infotype search_data)
{
binary_tree search_node = NULL;
F(root, search_data, &search_node);
return search_node;}
// Проходження всіх вузлів БД в прямому порядку
void GoStraight(binary_tree root)
{
if (root)
{
printf(printfspec, root->data);
GoStraight(WhoLeft(root));
GoStraight(WhoRight(root));
};}
// Проходження всіх вузлів БД в симетричному порядку
void GoSymmetric(binary_tree root)
{
if (root)
{
GoSymmetric(WhoLeft(root));
printf(printfspec, root->data);
GoSymmetric(WhoRight(root));
};}
// Проходження всіх вузлів БД у зворотньому порядку
void GoReverse(binary_tree root)
{
if (root)
{
GoReverse(WhoLeft(root));
GoReverse(WhoRight(root));
printf(printfspec, root->data);
};}
// Допоміжна функція для функції WhoFather
void WhoF(binary_tree root, binary_tree tree_node, binary_tree *father)
{
if (root && !*father)
{
if (WhoLeft(root) == tree_node || WhoRight(root) == tree_node)
*father = root;
else
{
WhoF(WhoLeft(root), tree_node, father);
WhoF(WhoRight(root), tree_node, father);
};
};}
// Пошук батька заданого вузла БД
binary_tree WhoFather(binary_tree root, binary_tree tree_node)
{
binary_tree father = NULL;
if (root != father)
WhoF(root, tree_node, &father);
return father;}
// Пошук брата заданого вузла БД
binary_tree WhoBrother(binary_tree root, binary_tree tree_node)
{
if (WhoLeft(WhoFather(root, tree_node)) == tree_node)
return WhoRight(WhoFather(root, tree_node));
else
return WhoLeft(WhoFather(root, tree_node));}
// Додавання вузла із заданим значенням в бінарне дерево пошуку
void AddSearchTree(binary_tree *root_ptr, infotype new_data)
{
if (!*root_ptr)
*root_ptr = MakeNode(new_data);
else
if (new_data < (*root_ptr)->data)
AddSearchTree(&((*root_ptr)->leftson), new_data);
else
AddSearchTree(&((*root_ptr)->rightson), new_data);}
// Допоміжна функція для функції DeleteSearchTree
void Del(binary_tree *root_ptr, binary_tree *del_node_ptr)
{
if (WhoLeft(*root_ptr))
Del(&((*root_ptr)->leftson), del_node_ptr);
else
{
(*del_node_ptr)->data = (*root_ptr)->data;
*del_node_ptr = *root_ptr;
*root_ptr = WhoRight(*root_ptr);
};}
// Вилучення вузла із заданим значенням з бінарного дерева пошуку
void DeleteSearchTree(binary_tree *root_ptr, infotype del_data)
{
binary_tree del_node;
if (*root_ptr)
if (del_data < (*root_ptr)->data)
DeleteSearchTree(&((*root_ptr)->leftson), del_data);
else
if (del_data > (*root_ptr)->data)
DeleteSearchTree(&((*root_ptr)->rightson), del_data);
else
{
del_node = *root_ptr;
if (!del_node->rightson)
*root_ptr = WhoLeft(del_node);
else
if (!WhoLeft(del_node))
*root_ptr = WhoRight(del_node);
else Del(&del_node->rightson, &del_node);
free(del_node);
};}
// Роздрук вузлів БД у звичайному вигляді (обмежується шириною екрану монітора)
// Приклад використання:PrintLevel(Tree,20,1);
void PrintLevel(binary_tree root, int k, int i)
{
char c;
if (root)
{
printf("\n");
for(c=1;c<=40+i;c++) printf(" ");
printf(printfspec,root->data);
PrintLevel(WhoLeft(root),k/2,i-k);
PrintLevel(WhoRight(root),k/2,i+k);
};
return;}
// Роздрук вузлів БД у перевернутому на 90 градусів вигляді
// Приклад використання: PrintTurningTree(Tree,2,1)
void PrintTurningTree(binary_tree root, int h)
{
int i;
if (root)
{
PrintTurningTree(WhoRight(root),h+1);
for (i=1;i<=h;i++) printf(" ");
printf(printfspec"\n",root->data);
PrintTurningTree(WhoLeft(root),h+1);
};}
pBTREE.h
// Інтерфейс обробки бінарного дерева (БД) пошуку
#define infotype int
#define printfspec "%d "
struct node
{
infotype data;
struct node *leftson, *rightson;
};
typedef struct node *binary_tree;
void Init(binary_tree *root_ptr);
int Empty(binary_tree root);
binary_tree WhoLeft(binary_tree tree_node);
binary_tree WhoRight(binary_tree tree_node);
void PutLeft(binary_tree root, infotype new_data);
void PutRight(binary_tree root, infotype new_data);
binary_tree Find(binary_tree root, infotype search_data);
void GoStraight(binary_tree root);
void GoSymmetric(binary_tree root);
void GoReverse(binary_tree root);
binary_tree WhoFather(binary_tree root, binary_tree knot);
binary_tree WhoBrother(binary_tree root, binary_tree knot);
void AddSearchTree(binary_tree *root_ptr, infotype new_data);
void DeleteSearchTree(binary_tree *root_ptr, infotype del_data);
void PrintLevel(binary_tree root, int k, int i);
void PrintTurningTree(binary_tree root, int h);
/----------------------------------------------------------------------------------/
testbtree.c
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include "pbtree.h"
void main()
{
binary_tree t1,p ;
// infotype x;
// unsigned i,n;
Init(&t1);
// printf("Enter the number of knots of binary tree: ");
// scanf("%d",&n);
//
// for (i=1;i<=n;i++)
// {
// scanf("%d",&x);
// AddSearchTreeWithDouble(&t1, x);
// };
AddSearchTree(&t1, 6);
AddSearchTree(&t1, 3);
AddSearchTree(&t1, 9);
AddSearchTree(&t1, 0);
AddSearchTree(&t1, -1);
printf("\n");
GoStraight(t1);
printf("\n");
GoSymmetric(t1);
printf("\n");
GoReverse(t1);
printf("\n");
printf("Find node: "printfspec,Find(t1,0)->data);
printf("\n");
if (p = WhoBrother(t1,Find(t1,9)))
printf("Brother node: "printfspec"\n",p->data);
else
printf("Brother node: NULL\n");
printf("Tree built:\n");
PrintLevel(t1,20,1);
printf("\n");
printf("Tree built:\n");
PrintTurningTree(t1,5);
printf("\n");
printf("Add 5,8,2,7,4 to tree :\n");
AddSearchTree(&t1,5);
AddSearchTree(&t1,8);
AddSearchTree(&t1,2);
AddSearchTree(&t1,7);
AddSearchTree(&t1,4);
printf("New tree:\n");
PrintLevel(t1,20,1);
printf("\n");
printf("New tree:\n");
PrintTurningTree(t1,5);
printf("\n");
printf("Delete 9 from tree :\n");
DeleteSearchTree(&t1,9);
PrintTurningTree(t1,5);
printf("\n");
getch();
return;}