BINARY TREE DONE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stddef.h>
#include <time.h>

int k = 0;

int randomazer (int min, int max){
    float random;
    random = rand();
    random = (random / RAND_MAX) * (max-min) + min;
    return((int)random);
}

typedef struct fff {
    int key;
    int lengh;
    struct fff *left;
    struct fff *right;
    struct fff *parent;
} node;


node* new_node (int key, node *parent){
    node *tmp = (node*)malloc(sizeof(node));
    tmp -> left = tmp -> right = NULL;
    tmp -> key = key;
    tmp -> parent = parent;
    tmp -> lengh = 1;
    if (parent!=NULL) {
        tmp -> lengh = tmp -> parent -> lengh +1;
    }
    if (k<tmp->lengh) k=tmp->lengh;
    return tmp;
}

void add_node (node **head, int key){
    if (*head == NULL){ //if tree empty
        *head = new_node (key, NULL);
    }
    else{
        node *iter = *head;
        while (iter){
            if (key >= (iter -> key)){
                if (iter -> right){
                    iter = iter -> right;
                }
                else{
                    iter -> right = new_node (key, iter);
                    break;
                }
            }
            else{
                if (iter -> left){
                    iter = iter -> left;
                }
                else{
                    iter -> left = new_node (key, iter);
                    break;
                }
            }
        }
    }
}

node* tree_search (node* head, int key){
    if (head == NULL)
        return NULL; //not founded
    if (key == head->key)
        return head;
    if (key < head->key)
        return tree_search (head->left, key);
    else
        return tree_search (head->right, key);
}

void output_tree (node *head) {
    node *iter = head;
    if (iter) {
        output_tree (iter -> left);
        printf("%d ", iter -> key);
        output_tree (iter -> right);
    }
}

int tree_minimum (node *head){
    while (head->left != NULL){
        head = head->left;
    }
    return head->key;
}

int tree_maximum (node *head){
    while (head->right != NULL){
        head = head->right;
    }
    return head->key;
}

int tree_successor (node *head, int key){
    int max;
    max = tree_maximum (head);
    if (key == max){
        printf ("This element has max value\n");
        return 0;
    }
    node *x;
    x = tree_search (head, key);
    if (x == NULL)
        return -1;
    if (x->right != NULL)
        return tree_minimum (x->right);
    node *iter;
    iter = x->parent;
    while ((iter != NULL)&&(iter->right)){
        head = iter;
        iter = iter->parent;
    }
    return iter->key;
}

int tree_predecessor (node *head, int key){
    int min;
    min = tree_minimum (head);
    if (key == min){
        printf ("This element has min value\n");
        return 0;
    }
    node *x;
    x = tree_search (head, key);
    if (x == NULL)
        return -1;
    if (x->left != NULL)
        return tree_maximum (x->left);
    node *iter;
    iter = x->parent;
    while ((iter != NULL)&&(iter->left)){
        head = iter;
        iter = iter->parent;
    }
    return iter->key;
}

void transplant (node **head, node *uu, node *v){
    if (uu->parent == NULL){
        *head = v;
    }
    else{
        if(uu == uu->parent->left)
            uu->parent->left = v;
        else
            uu->parent->right = v;
    }
    if (v != NULL)
        v->parent = uu->parent;
        free (uu);
}

void tree_delete (node **head, int key){
    node *z;
    z = tree_search (*head, key);
    if (z->left == NULL)
        transplant (&*head, z, z->right);
    else{
        if (z->right == NULL)
            transplant (head, z, z->left);
        else{
            node *y;
            int tmp;
            tmp = tree_minimum (z->right);
            y = tree_search (*head, tmp);
            if (y->parent != z){
                transplant (&*head, y, y->right);
                y->right = z->right;
                y->right->parent = y;
            }
            transplant (&*head, z, y);
            y->left = z->left;
            y->left->parent = y;
        }
    }
}


int main (void){
    int min, max, max_h, r;
    srand(time(NULL));
    printf ("Input min, max value and max hight of tree: ");
    scanf ("%d %d %d", &min, &max, &max_h);
    node *head = NULL;

    printf ("filling with random elements: \n");
    while (k < max_h){
        r = randomazer (min, max);
        printf ("%d ", r);
        add_node(&head, r);
    }
    printf ("\n");
    output_tree (head);
    printf ("\n\n");

    int behavior=1, behavior2=1, variety, variety2;
    int add_key, search_key, delete_key, max_key, min_key, key_6, key_7, next_key, previous_key;
    node *iter;
    iter = head;
    node *tmp_search;

    while (behavior2){
        printf ("Choose what u want:\n1-SEARCH\n2-ADD\n3-DELETE\n4-OUTPUT TREE\n5-MAX & MIN VALUE\n6-NEXT IN VALUE\n7-PREVIOUS IN VALUE\n8-WALK IN TREE\n0-If you want stop this\n");
        printf ("Your choice: ");
        scanf ("%d", &variety2);
        switch (variety2){

            case 1:
                printf ("Key, what you search: ");
                scanf ("%d", &search_key);
                tmp_search = tree_search (head, search_key);
                if (tmp_search == NULL)
                    printf ("No this key in tree\n");
                else
                    printf ("This key was founded\n");
                break;
            case 2:
                printf ("Added element:");
                scanf ("%d", &add_key);
                add_node (&head, add_key);
                printf ("\n");
                break;
            case 3:
                printf ("Key, which delete: ");
                scanf ("%d", &delete_key);
                tree_delete (&head, delete_key);
                printf ("Element was deleted\n");
                break;
            case 4:
                output_tree (head);
                printf ("\n");
                break;
            case 5:
                max_key = tree_maximum (head);
                min_key = tree_minimum (head);
                printf ("Min = %d, Max = %d\n", min_key, max_key);
                break;
            case 6:
                printf ("Input key: ");
                scanf ("%d", &key_6);
                next_key = tree_successor (head, key_6);
                if (next_key == -1)
                    printf ("No this element in tree\n");
                else{
                    if (next_key != 0)
                        printf ("Next key: %d\n", next_key);
                }
                break;
            case 7:
                printf ("Input key: ");
                scanf ("%d", &key_7);
                previous_key = tree_predecessor (head, key_7);
                if (previous_key == -1)
                    printf ("No this element in tree\n");
                else{
                    if (previous_key != 0)
                        printf ("Next key: %d\n", previous_key);
                }
                break;
            case 8:
                printf ("\n");
                while (behavior){
                    printf("Current node: %d\n", iter->key);
                    if(iter->left != NULL)
                        printf("Left child: %d\n", iter->left->key);
                    if(iter->right != NULL)
                        printf("Right child: %d\n", iter->right->key);
                    printf ("Choose what u want:\n1-Higher level\n2-To left son\n3-To right son\n0-If you want stop this\n");
                    printf ("Your choice: ");
                    scanf ("%d", &variety);
                    switch (variety){
                    case 1:
                        if(iter->parent != NULL)
                            iter = iter->parent;
                        else
                            printf("No parent node\n");
                        break;
                    case 2:
                        if (iter->left != NULL)
                            iter = iter->left;
                        else
                            printf ("The left child node is missing\n");
                        break;
                    case 3:
                        if (iter->right != NULL)
                            iter = iter->right;
                        else
                            printf ("The right child node is missing\n");
                        break;
                    case 0:
                        behavior = 0;
                        break;
                    default:
                        printf("Wrong input1\n" );
                        break;
                    }
                    printf ("\n");
                }
                break;
            case 0:
                behavior2 = 0;
                break;
            default:
                printf("Wrong input2\n" );
                break;
        }
        printf ("\n");
    }

    return 0;
}