TheAlgorithms-C/data_structures/binary_trees/binary_search_tree.c

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

/* A basic unbalanced binary search tree implementation in C, with the following
 functionalities implemented:
 - Insertion
 - Deletion
 - Search by key value
 - Listing of node keys in order of value (from left to right)
*/

// Node, the basic data structure in the tree
typedef struct node
{

    // left child
    struct node *left;

    // right child
    struct node *right;

    // data of the node
    int data;
} node;

// The node constructor, which receives the key value input and returns a node
// pointer
node *newNode(int data)
{

    // creates a slug
    node *tmp = (node *)malloc(sizeof(node));

    // initializes the slug
    tmp->data = data;
    tmp->left = NULL;
    tmp->right = NULL;

    return tmp;
}

// Insertion procedure, which inserts the input key in a new node in the tree
node *insert(node *root, int data)
{
    // If the root of the subtree is null, insert key here
    if (root == NULL)
        root = newNode(data);
    // If it isn't null and the input key is greater than the root key, insert
    // in the right leaf
    else if (data > root->data)
        root->right = insert(root->right, data);
    // If it isn't null and the input key is lower than the root key, insert in
    // the left leaf
    else if (data < root->data)
        root->left = insert(root->left, data);
    // Returns the modified tree
    return root;
}

// Utilitary procedure to find the greatest key in the left subtree
node *getMax(node *root)
{
    // If there's no leaf to the right, then this is the maximum key value
    if (root->right == NULL)
        return root;
    else
        root->right = getMax(root->right);
}

// Deletion procedure, which searches for the input key in the tree and removes
// it if present
node *delete (node *root, int data)
{
    // If the root is null, nothing to be done
    if (root == NULL)
        return root;
    // If the input key is greater than the root's, search in the right subtree
    else if (data > root->data)
        root->right = delete (root->right, data);
    // If the input key is lower than the root's, search in the left subtree
    else if (data < root->data)
        root->left = delete (root->left, data);
    // If the input key matches the root's, check the following cases
    // termination condition
    else if (data == root->data)
    {
        // Case 1: the root has no leaves, remove the node
        if ((root->left == NULL) && (root->right == NULL))
        {
            free(root);
            return NULL;
        }
        // Case 2: the root has one leaf, make the leaf the new root and remove
        // the old root
        else if (root->left == NULL)
        {
            node *tmp = root;
            root = root->right;
            free(tmp);
            return root;
        }
        else if (root->right == NULL)
        {
            node *tmp = root;
            root = root->left;
            free(tmp);
            return root;
        }
        // Case 3: the root has 2 leaves, find the greatest key in the left
        // subtree and switch with the root's
        else
        {

            // finds the biggest node in the left branch.
            node *tmp = getMax(root->left);

            // sets the data of this node equal to the data of the biggest node
            // (lefts)
            root->data = tmp->data;
            root->left = delete (root->left, tmp->data);
        }
    }
    return root;
}

// Search procedure, which looks for the input key in the tree and returns 1 if
// it's present or 0 if it's not in the tree
int find(node *root, int data)
{
    // If the root is null, the key's not present
    if (root == NULL)
        return 0;
    // If the input key is greater than the root's, search in the right subtree
    else if (data > root->data)
        return find(root->right, data);
    // If the input key is lower than the root's, search in the left subtree
    else if (data < root->data)
        return find(root->left, data);
    // If the input and the root key match, return 1
    else if (data == root->data)
        return 1;
}

// Utilitary procedure to measure the height of the binary tree
int height(node *root)
{
    // If the root is null, this is the bottom of the tree (height 0)
    if (root == NULL)
        return 0;
    else
    {
        // Get the height from both left and right subtrees to check which is
        // the greatest
        int right_h = height(root->right);
        int left_h = height(root->left);

        // The final height is the height of the greatest subtree(left or right)
        // plus 1(which is the root's level)
        if (right_h > left_h)
            return (right_h + 1);
        else
            return (left_h + 1);
    }
}

// Utilitary procedure to free all nodes in a tree
void purge(node *root)
{
    if (root != NULL)
    {
        if (root->left != NULL)
            purge(root->left);
        if (root->right != NULL)
            purge(root->right);
        free(root);
    }
}

// Traversal procedure to list the current keys in the tree in order of value
// (from the left to the right)
void inOrder(node *root)
{
    if (root != NULL)
    {
        inOrder(root->left);
        printf("\t[ %d ]\t", root->data);
        inOrder(root->right);
    }
}

void main()
{

    // this reference don't change.
    // only the tree changes.
    node *root = NULL;
    int opt = -1;
    int data = 0;

    // event-loop.
    while (opt != 0)
    {
        printf("\n\n[1] Insert Node\n[2] Delete Node\n[3] Find a Node\n[4] Get "
               "current Height\n[5] Print Tree in Crescent Order\n[0] Quit\n");
        scanf("%d", &opt); // reads the choice of the user

        // processes the choice
        switch (opt)
        {
        case 1:
            printf("Enter the new node's value:\n");
            scanf("%d", &data);
            root = insert(root, data);
            break;

        case 2:
            printf("Enter the value to be removed:\n");
            if (root != NULL)
            {
                scanf("%d", &data);
                root = delete (root, data);
            }
            else
                printf("Tree is already empty!\n");
            break;

        case 3:
            printf("Enter the searched value:\n");
            scanf("%d", &data);
            find(root, data) ? printf("The value is in the tree.\n")
                             : printf("The value is not in the tree.\n");
            break;

        case 4:
            printf("Current height of the tree is: %d\n", height(root));
            break;

        case 5:
            inOrder(root);
            break;
        }
    }

    // deletes the tree from the heap.
    purge(root);
}