How do I implement a binary tree in C?

How do I implement a binary tree in C?

To implement a binary tree in C, you need to define a structure for the tree nodes. Here's a simple example:

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

This structure contains an integer data and pointers to the left and right child nodes.

What functions do I need to add for inserting and traversing the tree?

You will need functions for inserting nodes and traversing the tree. For insertion, you can use a recursive function:

struct Node* insert(struct Node* node, int data) {
    if (node == NULL) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = data;
        newNode->left = newNode->right = NULL;
        return newNode;
    }
    if (data < node->data)
        node->left = insert(node->left, data);
    else
        node->right = insert(node->right, data);
    return node;
}

For traversal, you can implement in-order, pre-order, or post-order functions.

Can you show me an example of in-order traversal?

Sure! Here's an example of in-order traversal:

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

This function will print the nodes in ascending order.

What about deleting a node from the tree?

To delete a node, you need to find the node and then rearrange the tree. Here's a basic implementation:

struct Node* deleteNode(struct Node* root, int data) {
    if (root == NULL) return root;
    if (data < root->data)
        root->left = deleteNode(root->left, data);
    else if (data > root->data)
        root->right = deleteNode(root->right, data);
    else {
        if (root->left == NULL) {
            struct Node* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            struct Node* temp = root->left;
            free(root);
            return temp;
        }
        struct Node* temp = minValueNode(root->right);
        root->data = temp->data;
        root->right = deleteNode(root->right, temp->data);
    }
    return root;
}

This function handles different cases for deletion.