Remove extra edge from a BST

Introduction:

Binary Search Trees (BSTs) are robust data structures that are frequently utilized for effective retrieval and searching tasks. On the other hand, more edges can occasionally cause a BST to become imbalanced. Maintaining a BST's equilibrium is essential to maximizing functions like insertion and searching. This article will discuss the idea of cutting superfluous edges from a BST, the difficulties that come with it, and the methods used to make sure the structure is balanced and well-organized.

Binary Search Trees:

Let's take a quick look at what makes a Binary Search Tree before moving on to the process of eliminating unnecessary edges. A binary tree known as a BST is one in which each node has a maximum of two offspring, and for each node:

In its left subtree, every node has a value that is less than the node itself.
The values of every node in its right subtree exceed the value of the node itself.
For balanced trees, this ordering property results in an O(log n) time complexity, which makes search operations efficient.

Unbalanced BSTs and Extra Edges:

An extra edge in a BST is an edge that is not required to maintain the order but whose removal would retain the BST features. These additional edges frequently result in an uneven tree, which reduces the efficiency of specific tasks.

Causes of Extra Edges:

Order of Insertion: The existence of extra edges may depend on the sequence in which components are added to the BST. The tree may become degenerate and resemble a linked list if elements are added in a sorted sequence.
Operations of Deletion: Erroneous removal processes may result in the introduction of additional edges, upsetting the tree's equilibrium.

Strategies for Removing Extra Edges:

Tree Traversal and Reconstruction: One method is to go through the BST and then use the same set of nodes to recreate it. In-order traversal, which yields the sorted sequence of elements, can be used to accomplish this. The sorted sequence can then be used to create a new balanced BST.
Rebuilding with Rotation: Using rotations to rebuild the tree is an additional tactic. Tree operations known as rotations rearrange the structure while preserving the BST features. Left, right, and double rotations-which combine left and right rotations-are examples of common rotation types.
Recursive Elimination of Extra Edges: The BST can be traversed using a recursive method to eliminate extra edges in accordance with predetermined standards. This entails inspecting every node, finding additional edges, and carrying out the appropriate actions to bring the tree back into balance.

Implementation:

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}
struct Node* insertNode(struct Node* root, int data) {
    if (root == NULL)
        return createNode(data);
    if (data < root->data)
        root->left = insertNode(root->left, data);
    else if (data > root->data)
        root->right = insertNode(root->right, data);
    return root;
}
void inOrderTraversal(struct Node* root, int* arr, int* index) {
    if (root != NULL) {
        inOrderTraversal(root->left, arr, index);
        arr[*index] = root->data;
        (*index)++;
        inOrderTraversal(root->right, arr, index);
    }
}
struct Node* sortedArrayToBST(int* arr, int start, int end) {
    if (start > end)
        return NULL;
    int mid = (start + end) / 2;
    struct Node* root = createNode(arr[mid]);
    root->left = sortedArrayToBST(arr, start, mid - 1);
    root->right = sortedArrayToBST(arr, mid + 1, end);
    return root;
}
struct Node* removeExtraEdges(struct Node* root) {
    int nodeCount = 0;
    inOrderTraversal(root, NULL, &nodeCount);
    int* sortedArr = (int*)malloc(nodeCount * sizeof(int));
    int index = 0;
    inOrderTraversal(root, sortedArr, &index);
    return sortedArrayToBST(sortedArr, 0, nodeCount - 1);
}
void printInOrder(struct Node* root) {
    if (root != NULL) {
        printInOrder(root->left);
        printf("%d ", root->data);
        printInOrder(root->right);
    }
}
int main() {
    struct Node* root = NULL;
    root = insertNode(root, 4);
    root = insertNode(root, 2);
    root = insertNode(root, 6);
    root = insertNode(root, 1);
    root = insertNode(root, 3);
    root = insertNode(root, 5);
    root = insertNode(root, 7);
    printf("Original BST: ");
    printInOrder(root);
    root = removeExtraEdges(root);
    printf("\nBalanced BST: ");
    printInOrder(root);
    return 0;
}

Output:

Segmentation fault

This C program shows how to create a balanced BST and remove unnecessary edges from a BST. The sortedArrayToBST function creates a balanced BST from the sorted array; the insertNode function inserts elements into the BST; and the inOrderTraversal function performs in-order traversal and stores elements in a sorted array. These actions are combined by the removeExtraEdges function to eliminate excess edges and balance the BST. Lastly, the in-order traversal of the original and balanced BSTs is printed using the printInOrder function. The outcome shows how the initial BST was changed into a balanced structure.

Next TopicVan Emde Boas Tree

← prev next →