Building a Binary Tree in C

Introduction

Binary trees are fundamental data structures that serve a wide range of applications in computer science and software development. They are recursive data structures composed of nodes, where each node has at most two children - a left child and a right child. In this blog post, we will explore how to build a binary tree in C using the provided struct definition, and we will demonstrate the process through a simple example.

Defining the Binary Tree Structure

In C, we can define a binary tree using the following struct definition:

typedef struct BinaryTree {
    int data;
    struct BinaryTree* left;
    struct BinaryTree* right;
} BT;

Here, we have defined a structure named BinaryTree (abbreviated as BT) that consists of three members: data, left, and right. The data member stores the value of the current node, while left and right are pointers to the left and right children of the node, respectively.

Creating a New Node

Before we can start building our binary tree, we need a mechanism to create new nodes. We can do this using a function that allocates memory for a new node and initializes its values. The createNode function accomplishes this:

BT* createNode(int data) {
    BT* newNode = (BT*)malloc(sizeof(BT));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

The function createNode takes an integer data as input and returns a pointer to the newly created node. It dynamically allocates memory for the node using malloc and sets its data value to the provided input. The left and right pointers are initialized to NULL since the new node has no children at this point.

Insertion Operation

The insertion operation is crucial for building a binary tree. It allows us to add new nodes to the tree in their appropriate positions based on their values. We implement the insertNode function for this purpose:

BT* insertNode(BT* 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;
}

The insertNode function takes the current root of the binary tree and the new data to be inserted as input. It first checks if the root is NULL, which means the tree is empty. If so, it calls the createNode function to create a new node with the given data and sets it as the root of the tree.

If the tree is not empty, the function checks whether the new data should be placed in the left subtree or the right subtree. If the data is less than the value at the current node, it is inserted in the left subtree; otherwise, it is inserted in the right subtree. The function then recursively calls itself to continue traversing the tree until it finds an appropriate position to insert the new node.

In-Order Traversal

Traversing a binary tree allows us to visit each node in a specific order. One of the common traversal methods is the in-order traversal, which visits the left subtree first, then the current node, and finally the right subtree. We implement the inOrderTraversal function for this purpose:

void inOrderTraversal(BT* root) {
    if (root != NULL) {
        inOrderTraversal(root->left);
        printf("%d ", root->data);
        inOrderTraversal(root->right);
    }
}

The inOrderTraversal function takes the root of the binary tree as input and prints the elements of the tree in ascending order. It first recursively calls itself on the left subtree, then prints the current node's value, and finally, it calls itself on the right subtree.

The Main Function

Now that we have defined the essential functions, let's create a simple example to demonstrate how to use them:

int main() {
    BT* root = NULL;

    root = insertNode(root, 5);
    root = insertNode(root, 3);
    root = insertNode(root, 7);
    root = insertNode(root, 2);
    root = insertNode(root, 4);
    root = insertNode(root, 6);
    root = insertNode(root, 8);

    printf("In-order traversal: ");
    inOrderTraversal(root);
    printf("\n");

    freeBinaryTree(root);

    return 0;
}

In this example, we create a binary tree with elements 5, 3, 7, 2, 4, 6, and 8. We then perform an in-order traversal to display the elements in sorted order.

Conclusion

In this blog post, we explored the fundamental concepts of binary trees and learned how to build a binary tree in C using a custom struct definition. We implemented key functions for node creation, insertion, and in-order traversal. Binary trees serve as a powerful tool for many algorithms, and understanding how to create and manipulate them is a valuable skill for any programmer.

Find out more about trees in the Unlocking the Secrets of Trees blog post from my Data Structures series. And please tune in to the C Magic series where we will explore other data structure implementations as well.

Feel free to chat with me on Twitter as well.

Happy coding!