Remove all multiples of K from Binary Tree

Given a binary tree and an integer K, the task is to remove all the nodes which are multiples of K from the given binary tree.

Examples:

Input:
           1
         /    \
        2      3
       / \    /
      4   5  8
     / \    /
    6   7  9
Output:
Level Order Traversal of Given Binary Tree:
1 
2 3 
4 5 8 
6 7 9 

Level Order Traversal of Updated Binary Tree:
1 
5 3 
7 9

Approach:



  1. Convert the given Binary Tree to Doubly Linked List.
  2. Remove all nodes which are multiples of K from the created doubly linked list.
  3. Convert the updated doubly linked list back to a binary tree.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
struct node {
    int data;
    node *left, *right;
};
  
node* newnode(int data)
{
    node* temp = new node;
    temp->data = data;
    temp->left = temp->right = NULL;
  
    return temp;
}
  
// Level order traversal of the tree
void printTree(node* root)
{
  
    if (!root)
        return;
  
    queue<node*> q;
    q.push(root);
  
    while (!q.empty()) {
  
        int n = q.size();
        while (n--) {
            node* temp = q.front();
            q.pop();
  
            cout << temp->data << " ";
  
            if (temp->left)
                q.push(temp->left);
  
            if (temp->right)
                q.push(temp->right);
        }
        cout << endl;
    }
}
  
// Function to convert binary tree
// to doubly linked list
void BT2DLL(node* root, node*& head)
{
    // Base Case
    if (root == NULL)
        return;
  
    static node* left = NULL;
  
    // Traverse the left subtree
    BT2DLL(root->left, head);
  
    // Assign head to leftmost node
    if (left == NULL)
        head = root;
  
    else {
        root->left = left;
        left->right = root;
    }
  
    left = root;
  
    // Traverse the right subtree
    BT2DLL(root->right, head);
}
  
// Function to delete the current node
// from the doubly linked list
void deletenode(node*& head, node* del)
{
    // Base case
    if (head == NULL || del == NULL)
        return;
  
    // If node to be deleted is head node
    if (head == del)
        head = del->right;
  
    // Change right only if node to be deleted
    // is NOT the last node
    if (del->right != NULL)
        del->right->left = del->left;
  
    // Change left only if node to be deleted
    // is NOT the first node
    if (del->left != NULL)
        del->left->right = del->right;
  
    // Finally, free the memory occupied by del
    free(del);
}
  
// Function to remove the multiples of k
// from doubly linked list
void removeKeys(node*& head, int k)
{
  
    if (head == NULL)
        return;
  
    node* current = head;
    node* right;
  
    while (current != NULL) {
  
        // If multiple of k then remove this node
        if (current->data % k == 0) {
  
            // Save current's right node in the
            // pointer 'right'
            right = current->right;
  
            // Delete the node pointed to by
            // 'current'
            deletenode(head, current);
  
            // Update current
            current = right;
        }
  
        // Else simply move to the right node
        else
            current = current->right;
    }
}
  
// Function to convert doubly linked list
// to binary tree
node* DLLtoBT(node*& head, int n)
{
  
    if (n <= 0)
        return NULL;
  
    node* left = DLLtoBT(head, n / 2);
    node* root = head;
    root->left = left;
    head = head->right;
    root->right = DLLtoBT(head, n - n / 2 - 1);
  
    return root;
}
  
// Function that removes the multiples
// of k from the given binary tree
node* removeMultiplesUtil(node* root, int k)
{
  
    node* head = NULL;
  
    // Convert Binary Tree to DLL
    BT2DLL(root, head);
  
    // Remove multiples of k from DLL
    removeKeys(head, k);
  
    node* temp = head;
    int n = 0;
  
    // Get Size of the updated list
    while (temp) {
        ++n;
        temp = temp->right;
    }
  
    // Convert DLL to Binary Tree
    return DLLtoBT(head, n);
}
  
// Function to call the utility function
// that removes the multiples of k
// from the given binary tree
void removeMultiples(node*& root, int k)
{
  
    if (!root)
        return;
  
    root = removeMultiplesUtil(root, k);
}
  
// Driver code
int main()
{
  
    int k = 2;
    node* root = newnode(1);
    root->left = newnode(2);
    root->right = newnode(3);
    root->left->left = newnode(4);
    root->left->right = newnode(5);
    root->left->left->left = newnode(6);
    root->left->left->right = newnode(7);
    root->right->left = newnode(8);
    root->right->left->left = newnode(9);
  
    cout << "Level Order Traversal of Given Binary Tree:\n";
    printTree(root);
  
    removeMultiples(root, k);
  
    cout << "\nLevel Order Traversal of Updated Binary Tree:\n";
    printTree(root);
  
    return 0;
}

chevron_right


Output:

Level Order Traversal of Given Binary Tree:
1 
2 3 
4 5 8 
6 7 9 

Level Order Traversal of Updated Binary Tree:
1 
5 3 
7 9


My Personal Notes arrow_drop_up

A Coding Enthusiast Rails Developer

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.