Класс красно-черное дерево: исправить ошибку

class RBTree
{
private:
    struct rbNode 
    {
        rbNode(int data);
        int data, color;
        struct rbNode *link[2];
    };
 public:
    rbNode *root;
    //......

class RBTree
{
private:
    struct rbNode 
    {
        rbNode(int data);
        int data, color;
        struct rbNode *link[2];
    };
    rbNode *root;
    int depth;
 
public:
    enum nodeColor 
    {
        RED,
        BLACK
    };      
 
    RBTree();
    void insertion (int data);
    void deletion(int data);
    void searchElement(int data);
    void inorderTraversal();
    
    void Get(struct rbNode *node)
    {
        if (node)
        {
        Get(node->link[0]);
        printf("%d ", node->data);
        Get(node->link[1]);
        }
    }
};
 
RBTree::rbNode::rbNode( int _data )
{
    data = _data;
        color = RED;
    link[0] = link[1] = NULL;
}
 
RBTree::RBTree()
{ 
    root = NULL;
    depth = NULL;//глубина
}
 
void RBTree::insertion ( int data )//ф-ия вставки элемента
{
    struct rbNode *ptr, *newnode, *xPtr, *yPtr;
    int ht = 0, index;
    int _depth = depth;
    struct rbNode** stack; 
    stack = new rbNode*[_depth];
    int* dir;
    dir = new int [_depth];
    ptr = root;//корень 
    if (!root)//пока не наш корень
    {
        root = new rbNode(data);//записываем данные
        return;
    }
    stack[ht] = root;//в массив переписываем значение корня
    dir[ht++] = 0;//обнуляем все значения дальше корня
 
    /* находим место для записи элемента */
    while (ptr != NULL)//пока есть элементы
    {
        if (ptr->data == data) //они равны входящим данным
        {
            printf("This data was insert earlier! \n");
            return;
        }
        index = (data - ptr->data) > 0 ? 1 : 0;//в противном случае: если 
        stack[ht] = ptr;//записываем значение
        ptr = ptr->link[index];//изменяем корень
        dir[ht++] = index;
    }
    /* вставляем элемент */
    stack[ht - 1]->link[index] = newnode = new rbNode(data);//создаем новое дерево
    while ((ht >= 3) && (stack[ht - 1]->color == RED))//пока есть элементы дальше и они красные
    {
        if (dir[ht - 2] == 0) 
        {
            yPtr = stack[ht - 2]->link[1];
            if (yPtr != NULL && yPtr->color == RED)
            {
                stack[ht - 2]->color = RED;
                stack[ht - 1]->color = yPtr->color = BLACK;//"очерняем"
                ht = ht - 2;
            } 
            else 
            {
                if (dir[ht - 1] == 0) 
                {
                    yPtr = stack[ht - 1];
                } 
                else
                {
                    xPtr = stack[ht - 1];
                    yPtr = xPtr->link[1];
                    xPtr->link[1] = yPtr->link[0];//меняем
                    yPtr->link[0] = xPtr;
                    stack[ht - 2]->link[0] = yPtr;
                }
                xPtr = stack[ht - 2];//если не последний
                xPtr->color = RED;//закрашиваем красным
                yPtr->color = BLACK;//последние(листья) - черными
                xPtr->link[0] = yPtr->link[1];
                yPtr->link[1] = xPtr;
                if (xPtr == root)//если равно корню
                {
                    root = yPtr;//корень
                } 
                else 
                {
                    stack[ht - 3]->link[dir[ht - 3]] = yPtr;
                }
                break;
            }
        } 
        else 
        {
            yPtr = stack[ht - 2]->link[0];
            if ((yPtr != NULL) && (yPtr->color == RED)) 
            {
                stack[ht - 2]->color = RED;
                stack[ht - 1]->color = yPtr->color = BLACK;
                ht = ht - 2;
            } else 
            {
                if (dir[ht - 1] == 1) 
                {
                    yPtr = stack[ht - 1];
                } 
                else 
                {
                    xPtr = stack[ht - 1];
                    yPtr = xPtr->link[0];
                    xPtr->link[0] = yPtr->link[1];
                    yPtr->link[1] = xPtr;
                    stack[ht - 2]->link[1] = yPtr;
                }
                xPtr = stack[ht - 2];
                yPtr->color = BLACK;
                xPtr->color = RED;
                xPtr->link[1] = yPtr->link[0];
                yPtr->link[0] = xPtr;
                if (xPtr == root) 
                {
                    root = yPtr;
                } 
                else 
                {
                    stack[ht - 3]->link[dir[ht - 3]] = yPtr;
                }
                break;
            }
        }
    }
    delete []dir;
    delete []stack;
    root->color = BLACK;
}
 
void RBTree::deletion( int data )//функция удаления
{
    struct rbNode *ptr, *xPtr, *yPtr;
    struct rbNode *pPtr, *qPtr, *rPtr;
    int ht = 0, diff, i;
    struct rbNode** stack; 
    stack = new rbNode*[depth + 1];
    int* dir;
    dir = new int [depth + 1];
 
    enum nodeColor color;
 
    if (!root)//если не корень
    {
        printf("Tree not available\n");//не доступно дерево
        return;
    }
    ptr = root;
    /* ищем узел для удаления */
    while (ptr != NULL)
    {
        if ((data - ptr->data) == 0)
            break;
        diff = (data - ptr->data) > 0 ? 1 : 0;//если значения есть, то вернуть 1, в противном случае 0
        stack[ht] = ptr;//записываем корень
        dir[ht++] = diff;//значение
        ptr = ptr->link[diff];
    }
 
    if (ptr->link[1] == NULL)//узел без детей
    {
        if ((ptr == root) && (ptr->link[0] == NULL)) 
        {
            free(ptr);
            root = NULL;
        } 
        else 
            if (ptr == root) 
        {
            root = ptr->link[0];//удаляем узел - с одним сыном
            free(ptr);
        } 
        else 
        {
            //узел с одним сыном
            stack[ht - 1]->link[dir[ht - 1]] = ptr->link[0];
        }
    } 
    else 
    {
        xPtr = ptr->link[1];
        if (xPtr->link[0] == NULL) //если узел с 2мя сыновьями - удалить узел, чей правый сын не является предком левого
        {
            xPtr->link[0] = ptr->link[0];
            color = (xPtr->color == 0) ? RED:BLACK;//если значение 0, то красный
            xPtr->color = ptr->color;
            ptr->color = color;//закрашиваем
 
            if (ptr == root) //если равно корню
            {
                root = xPtr;//переписываем
            } 
            else 
            {
                stack[ht - 1]->link[dir[ht - 1]] = xPtr;//если нет, то помещаем в массив
            }
 
            dir[ht] = 1;
            stack[ht++] = xPtr;
        } 
        else 
        {
            i = ht++;//удаляем узелл с двумя детьми
            while (1) 
            {
                dir[ht] = 0;
                stack[ht++] = xPtr;
                yPtr = xPtr->link[0];
                if (!yPtr->link[0])
                    break;
                xPtr = yPtr;
            }
 
            dir[i] = 1;
            stack[i] = yPtr;
            if (i > 0)
                stack[i - 1]->link[dir[i - 1]] = yPtr;
 
            yPtr->link[0] = ptr->link[0];
            xPtr->link[0] = yPtr->link[1];
            yPtr->link[1] = ptr->link[1];
 
            if (ptr == root) 
            {
                root = yPtr;
            }
 
            color = (yPtr->color==0) ? RED:BLACK;
            yPtr->color = ptr->color;
            ptr->color = color;
        }
    }
    if (ht < 1)
        return;
    if (ptr->color == BLACK) 
    {
        while (1) 
        {
            pPtr = stack[ht - 1]->link[dir[ht - 1]];
            if (pPtr && pPtr->color == RED) 
            {
                pPtr->color = BLACK;
                break;
            }
 
            if (ht < 2)
                break;
 
            if (dir[ht - 2] == 0) 
            {
                rPtr = stack[ht - 1]->link[1];
 
                if (!rPtr)
                    break;
 
                if (rPtr->color == RED)
                {
                    stack[ht - 1]->color = RED;
                    rPtr->color = BLACK;
                    stack[ht - 1]->link[1] = rPtr->link[0];
                    rPtr->link[0] = stack[ht - 1];
 
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    dir[ht] = 0;
                    stack[ht] = stack[ht - 1];
                    stack[ht - 1] = rPtr;
                    ht++;
 
                    rPtr = stack[ht - 1]->link[1];
                }
 
                if ( (!rPtr->link[0] || rPtr->link[0]->color == BLACK) && (!rPtr->link[1] || rPtr->link[1]->color == BLACK)) 
                {
                    rPtr->color = RED;
                } else {
                    if (!rPtr->link[1] || rPtr->link[1]->color == BLACK) 
                    {
                        qPtr = rPtr->link[0];
                        rPtr->color = RED;
                        qPtr->color = BLACK;
                        rPtr->link[0] = qPtr->link[1];
                        qPtr->link[1] = rPtr;
                        rPtr = stack[ht - 1]->link[1] = qPtr;
                    }
                    rPtr->color = stack[ht - 1]->color;
                    stack[ht - 1]->color = BLACK;
                    rPtr->link[1]->color = BLACK;
                    stack[ht - 1]->link[1] = rPtr->link[0];
                    rPtr->link[0] = stack[ht - 1];
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    break;
                }
            } 
            else 
            {
                rPtr = stack[ht - 1]->link[0];
                if (!rPtr)
                    break;
 
                if (rPtr->color == RED) 
                {
                    stack[ht - 1]->color = RED;
                    rPtr->color = BLACK;
                    stack[ht - 1]->link[0] = rPtr->link[1];
                    rPtr->link[1] = stack[ht - 1];
 
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    dir[ht] = 1;
                    stack[ht] = stack[ht - 1];
                    stack[ht - 1] = rPtr;
                    ht++;
 
                    rPtr = stack[ht - 1]->link[0];
                }
                if ( (!rPtr->link[0] || rPtr->link[0]->color == BLACK) && (!rPtr->link[1] || rPtr->link[1]->color == BLACK)) 
                {
                    rPtr->color = RED;
                } 
                else 
                {
                    if (!rPtr->link[0] || rPtr->link[0]->color == BLACK) 
                    {
                        qPtr = rPtr->link[1];
                        rPtr->color = RED;
                        qPtr->color = BLACK;
                        rPtr->link[1] = qPtr->link[0];
                        qPtr->link[0] = rPtr;
                        rPtr = stack[ht - 1]->link[0] = qPtr;
                    }
                    rPtr->color = stack[ht - 1]->color;
                    stack[ht - 1]->color = BLACK;
                    rPtr->link[0]->color = BLACK;
                    stack[ht - 1]->link[0] = rPtr->link[1];
                    rPtr->link[1] = stack[ht - 1];
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    break;
                }
            }
            ht--;
        }
    }
    delete[]stack;
    delete[]dir;
}
 
void RBTree::searchElement( int data ) //ф-ия поиска элемента
{
    struct rbNode *temp = root;
    int diff;
 
    while (temp != NULL) //если не равно нулю
    {
        diff = data - temp->data;//имеющиеся элементы
        if (diff > 0) //пока есть элементы
        {
            temp = temp->link[1];
        } 
        else 
            if (diff < 0) 
            {
                temp = temp->link[0];
            } 
            else //нашли значение
            {
                printf("Search Element Found!!\n");
                return;
            }
    }
    printf("Given Data Not Found in RB Tree!!\n");//не нашли значение
    return;
}
 
void RBTree::inorderTraversal()//напечатать значения, которые в дереве
{
    Get(root);
    return;
}
 
int main() 
{
    int ch, data, time = clock();
    RBTree tree;
    while (1) 
    {
        printf("Time is: %d\n", time);
        printf("1. Insertion\t2. Deletion\n");
        printf("3. Searching\t4. Traverse\n");
        printf("5. Exit\nEnter your choice:");
        scanf("%d", &ch);
        switch (ch) 
        {
        case 1:
            printf("Enter the data to insert:");
            scanf("%d", &data);
            tree.insertion(data);
            break;
        case 2:
            printf("Enter the data to delete:");
            scanf("%d", &data);
            tree.deletion(data);
            break;
        case 3:
            printf("Enter the search element:");
            scanf("%d", &data);
            tree.searchElement(data);
            break;
        case 4:
            tree.inorderTraversal();
            printf("\n");
            break;
        case 5:
            exit(0);
        default:
            printf("You have entered wrong option!!\n");
            break;
        }
        printf("\n");
    }
    return 0;
}

class RBTree
{
private:
    struct rbNode 
    {
        rbNode(int data);
        int data, color;
        struct rbNode *link[2];
    };
    rbNode *root;
    int depth;
 
public:
    enum nodeColor 
    {
        RED,
        BLACK
    };      
 
    RBTree();
    void insertion (int data);
    void deletion(int data);
    void searchElement(int data);
    void inorderTraversal();
    
    void Get(struct rbNode *node)
    {
        if (node)
        {
        Get(node->link[0]);
        printf("%d ", node->data);
        Get(node->link[1]);
        }
    }
};
 
RBTree::rbNode::rbNode( int _data )
{
    data = _data;
    color = RED;
    link[0] = link[1] = NULL;
}
 
RBTree::RBTree()
{ 
    root = NULL;
    depth = NULL;//глубина
}
 
void RBTree::insertion ( int data )//ф-ия вставки элемента
{
    struct rbNode *ptr, *newnode, *xPtr, *yPtr;
    int ht = 0, index;
    struct rbNode** stack; 
    stack = new rbNode*[depth];
    int* dir;
    dir = new int [depth];
    ptr = root;//корень 
    if (!root)//пока не наш корень
    {
        root = new rbNode(data);//новый узел = корню
        depth = 1;
        return;
    }
    //stack[ht] = root;//в массив переписываем новый узел = корень
    //dir[ht++] = 0;//обнуляем все значения дальше корня
 
    /* находим место для записи элемента */
    while (ptr != NULL)//пока есть элементы
    {
        if (ptr->data == data) //они равны входящим данным
        {
            printf("This data was insert earlier! \n");
            return;
        }
        index = (data - ptr->data) > 0 ? 1 : 0;//в противном случае: если
        //_depth = _depth + 1; 
        stack[ht] = ptr;//записываем значение
        ptr = ptr->link[index];//переходим к новому элементу
        dir[ht++] = index; 
    }
    /* вставляем элемент */
    stack[ht - 1]->link[index] = newnode = new rbNode(data);//создаем новый узел
 
    if ((ht + 1) > depth)
    {
        depth = ht + 1;
    }
 
    while ((ht >= 3) && (stack[ht - 1]->color == RED))//пока есть элементы дальше и они красные
    {
        if (dir[ht - 2] == 0) 
        {
            yPtr = stack[ht - 2]->link[1];
            if (yPtr != NULL && yPtr->color == RED)
            {
                stack[ht - 2]->color = RED;
                stack[ht - 1]->color = yPtr->color = BLACK;//"очерняем"
                ht = ht - 2;
            } 
            else 
            {
                if (dir[ht - 1] == 0) 
                {
                    yPtr = stack[ht - 1];
                } 
                else 
                {
                    xPtr = stack[ht - 1];
                    yPtr = xPtr->link[1];
                    xPtr->link[1] = yPtr->link[0];//меняем
                    yPtr->link[0] = xPtr;
                    stack[ht - 2]->link[0] = yPtr;
                }
                xPtr = stack[ht - 2];
                xPtr->color = RED;//закрашиваем красным корень
                yPtr->color = BLACK;//черным
                xPtr->link[0] = yPtr->link[1];
                yPtr->link[1] = xPtr;
                if (xPtr == root)//если равно корню
                {
                    root = yPtr;//корень
                } 
                else 
                {
                    stack[ht - 3]->link[dir[ht - 3]] = yPtr;
                }
                break;
            }
        } 
        else 
        {
            yPtr = stack[ht - 2]->link[0];
            if ((yPtr != NULL) && (yPtr->color == RED)) 
            {
                stack[ht - 2]->color = RED;
                stack[ht - 1]->color = yPtr->color = BLACK;
                ht = ht - 2;
            } else 
            {
                if (dir[ht - 1] == 1) 
                {
                    yPtr = stack[ht - 1];
                } 
                else 
                {
                    xPtr = stack[ht - 1];
                    yPtr = xPtr->link[0];
                    xPtr->link[0] = yPtr->link[1];
                    yPtr->link[1] = xPtr;
                    stack[ht - 2]->link[1] = yPtr;
                }
                xPtr = stack[ht - 2];
                yPtr->color = BLACK;
                xPtr->color = RED;
                xPtr->link[1] = yPtr->link[0];
                yPtr->link[0] = xPtr;
                if (xPtr == root) 
                {
                    root = yPtr;
                } 
                else 
                {
                    stack[ht - 3]->link[dir[ht - 3]] = yPtr;
                }
                break;
            }
        }
    }
    delete []dir;
    delete []stack;
    root->color = BLACK;
}
 
void RBTree::deletion( int data )//функция удаления
{
    struct rbNode *ptr, *xPtr, *yPtr;
    struct rbNode *pPtr, *qPtr, *rPtr;
    int ht = 0, diff, i;
    struct rbNode** stack; 
    stack = new rbNode*[depth + 1];
    int* dir;
    dir = new int [depth + 1];
 
    enum nodeColor color;
 
    if (!root)//если не корень
    {
        printf("Tree not available\n");//не доступно дерево
        return;
    }
    ptr = root;
    /* ищем узел для удаления */
    while (ptr != NULL)
    {
        if ((data - ptr->data) == 0)
            break;
        diff = (data - ptr->data) > 0 ? 1 : 0;//если значения есть, то вернуть 1, в противном случае 0
        stack[ht] = ptr;//записываем корень
        dir[ht++] = diff;//значение
        ptr = ptr->link[diff];
    }
 
    if (ptr->link[1] == NULL)//узел без детей
    {
        if ((ptr == root) && (ptr->link[0] == NULL)) 
        {
            free(ptr);
            root = NULL;
        } 
        else 
            if (ptr == root) 
        {
            root = ptr->link[0];//удаляем узел - с одним сыном
            free(ptr);
        } 
        else 
        {
            //узел с одним сыном
            stack[ht - 1]->link[dir[ht - 1]] = ptr->link[0];
        }
    } 
    else 
    {
        xPtr = ptr->link[1];
        if (xPtr->link[0] == NULL) //если узел с 2мя сыновьями - удалить узел, чей правый сын не является предком левого
        {
            xPtr->link[0] = ptr->link[0];
            color = (xPtr->color == 0) ? RED:BLACK;//если значение 0, то красный
            xPtr->color = ptr->color;
            ptr->color = color;//закрашиваем
 
            if (ptr == root) //если равно корню
            {
                root = xPtr;//переписываем
            } 
            else 
            {
                stack[ht - 1]->link[dir[ht - 1]] = xPtr;//если нет, то помещаем в массив
            }
 
            dir[ht] = 1;
            stack[ht++] = xPtr;
        } 
        else 
        {
            i = ht++;//удаляем узелл с двумя детьми
            while (1) 
            {
                dir[ht] = 0;
                stack[ht++] = xPtr;
                yPtr = xPtr->link[0];
                if (!yPtr->link[0])
                    break;
                xPtr = yPtr;
            }
 
            dir[i] = 1;
            stack[i] = yPtr;
            if (i > 0)
                stack[i - 1]->link[dir[i - 1]] = yPtr;
 
            yPtr->link[0] = ptr->link[0];
            xPtr->link[0] = yPtr->link[1];
            yPtr->link[1] = ptr->link[1];
 
            if (ptr == root) 
            {
                root = yPtr;
            }
 
            color = (yPtr->color==0) ? RED:BLACK;
            yPtr->color = ptr->color;
            ptr->color = color;
        }
    }
    if (ht < 1)
        return;
    if (ptr->color == BLACK) 
    {
        while (1) 
        {
            pPtr = stack[ht - 1]->link[dir[ht - 1]];
            if (pPtr && pPtr->color == RED) 
            {
                pPtr->color = BLACK;
                break;
            }
 
            if (ht < 2)
                break;
 
            if (dir[ht - 2] == 0) 
            {
                rPtr = stack[ht - 1]->link[1];
 
                if (!rPtr)
                    break;
 
                if (rPtr->color == RED)
                {
                    stack[ht - 1]->color = RED;
                    rPtr->color = BLACK;
                    stack[ht - 1]->link[1] = rPtr->link[0];
                    rPtr->link[0] = stack[ht - 1];
 
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    dir[ht] = 0;
                    stack[ht] = stack[ht - 1];
                    stack[ht - 1] = rPtr;
                    ht++;
 
                    rPtr = stack[ht - 1]->link[1];
                }
 
                if ( (!rPtr->link[0] || rPtr->link[0]->color == BLACK) && (!rPtr->link[1] || rPtr->link[1]->color == BLACK)) 
                {
                    rPtr->color = RED;
                } 
                else 
                {
                    if (!rPtr->link[1] || rPtr->link[1]->color == BLACK) 
                    {
                        qPtr = rPtr->link[0];
                        rPtr->color = RED;
                        qPtr->color = BLACK;
                        rPtr->link[0] = qPtr->link[1];
                        qPtr->link[1] = rPtr;
                        rPtr = stack[ht - 1]->link[1] = qPtr;
                    }
                    rPtr->color = stack[ht - 1]->color;
                    stack[ht - 1]->color = BLACK;
                    rPtr->link[1]->color = BLACK;
                    stack[ht - 1]->link[1] = rPtr->link[0];
                    rPtr->link[0] = stack[ht - 1];
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    break;
                }
            } 
            else 
            {
                rPtr = stack[ht - 1]->link[0];
                if (!rPtr)
                    break;
 
                if (rPtr->color == RED) 
                {
                    stack[ht - 1]->color = RED;
                    rPtr->color = BLACK;
                    stack[ht - 1]->link[0] = rPtr->link[1];
                    rPtr->link[1] = stack[ht - 1];
 
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    dir[ht] = 1;
                    stack[ht] = stack[ht - 1];
                    stack[ht - 1] = rPtr;
                    ht++;
 
                    rPtr = stack[ht - 1]->link[0];
                }
                if ( (!rPtr->link[0] || rPtr->link[0]->color == BLACK) && (!rPtr->link[1] || rPtr->link[1]->color == BLACK)) 
                {
                    rPtr->color = RED;
                } 
                else 
                {
                    if (!rPtr->link[0] || rPtr->link[0]->color == BLACK) 
                    {
                        qPtr = rPtr->link[1];
                        rPtr->color = RED;
                        qPtr->color = BLACK;
                        rPtr->link[1] = qPtr->link[0];
                        qPtr->link[0] = rPtr;
                        rPtr = stack[ht - 1]->link[0] = qPtr;
                    }
                    rPtr->color = stack[ht - 1]->color;
                    stack[ht - 1]->color = BLACK;
                    rPtr->link[0]->color = BLACK;
                    stack[ht - 1]->link[0] = rPtr->link[1];
                    rPtr->link[1] = stack[ht - 1];
                    if (stack[ht - 1] == root) 
                    {
                        root = rPtr;
                    } 
                    else 
                    {
                        stack[ht - 2]->link[dir[ht - 2]] = rPtr;
                    }
                    break;
                }
            }
            ht--;
        }
    }
    delete[]stack;
    delete[]dir;
}
 
void RBTree::searchElement( int data ) //ф-ия поиска элемента
{
    struct rbNode *temp = root;
    int diff;
 
    while (temp != NULL) //если не равно нулю
    {
        diff = data - temp->data;//имеющиеся элементы
        if (diff > 0) //пока есть элементы
        {
            temp = temp->link[1];
        } 
        else 
            if (diff < 0) 
            {
                temp = temp->link[0];
            } 
            else //нашли значение
            {
                printf("Search Element Found!!\n");
                return;
            }
    }
    printf("Given Data Not Found in RB Tree!!\n");//не нашли значение
    return;
}
 
void RBTree::inorderTraversal()//напечатать значения, которые в дереве
{
    Get(root);
    return;
}
 
int main() 
{
    int ch, data, time = clock();
    RBTree tree;
    while (1) 
    {
        printf("1. Insertion\t2. Deletion\n");
        printf("3. Searching\t4. Traverse\n");
        printf("5. Exit\nEnter your choice:");
        scanf("%d", &ch);
        switch (ch) 
        {
        case 1:
            printf("Enter the data to insert:");
            scanf("%d", &data);
            tree.insertion(data);
            break;
        case 2:
            printf("Enter the data to delete:");
            scanf("%d", &data);
            tree.deletion(data);
            break;
        case 3:
            printf("Enter the search element:");
            scanf("%d", &data);
            tree.searchElement(data);
            break;
        case 4:
            tree.inorderTraversal();
            printf("\n");
            break;
        case 5:
            exit(0);
        default:
            printf("You have entered wrong option!!\n");
            break;
        }
        printf("\n");
    }
    return 0;
}