Related Articles

Related Articles

Remove vowels from a string stored in a Binary Tree
  • Difficulty Level : Medium
  • Last Updated : 18 Feb, 2020

Given a binary tree in such a way such that the level order traversal of a binary tree produces a string S. The task is to remove all vowels from the binary tree and print the level order traversal of the remaining tree.

Examples:

Input: 
     G
   /   \
  E     E
 / \ 
K   S

Output:
     G
   /   \
  K     S

Input:
     G
   /   \
  O     A
 /  
L   

Output:
     G 
   / 
  L    

Approach:

  1. Perform a level order insertion of the characters in the string.
  2. Declare a new binary tree with its root set to NULL.
  3. Perform a level order traversal of the binary tree.
  4. In case a vowel is encountered, do not add it to the new binary tree.
  5. Otherwise add the character to the new binary tree.
  6. Perform a level order traversal of the new tree.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program
// for the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Structure Representing
// the Node in the Binary tree
struct Node {
    char data;
    Node *left, *right;
    Node(char _val)
    {
        data = _val;
        left = right = NULL;
    }
};
  
// Function to perform a level
// order insertion of a new Node
// in the Binary tree
Node* addinBT(Node* root, char data)
{
    // If the root is empty,
    // make it point to the new Node
    if (root == NULL) {
        root = new Node(data);
    }
    else {
  
        // In case there are elements
        // in the Binary tree, perform
        // a level order traversal
        // using a Queue
        queue<Node*> Q;
        Q.push(root);
  
        while (!Q.empty()) {
            Node* temp = Q.front();
            Q.pop();
            // If the left child does
            // not exist, insert the
            // new Node as the left child
            if (temp->left == NULL) {
                temp->left = new Node(data);
                break;
            }
            else
                Q.push(temp->left);
            // In case the right child
            // does not exist, insert
            // the new Node as the right child
            if (temp->right == NULL) {
                temp->right = new Node(data);
                break;
            }
            else
                Q.push(temp->right);
        }
    }
    return root;
}
  
// Function to print the level
// order traversal of the Binary tree
void print(Node* root)
{
  
    queue<Node*> Q;
    Q.push(root);
  
    while (Q.size()) {
        Node* temp = Q.front();
        Q.pop();
        cout << temp->data;
        if (temp->left)
            Q.push(temp->left);
        if (temp->right)
            Q.push(temp->right);
    }
}
  
// Function to check if the
// character is a vowel or not.
bool checkvowel(char ch)
{
    ch = tolower(ch);
    if (ch == 'a' || ch == 'e' || ch == 'i' 
                  || ch == 'o' || ch == 'u') {
        return true;
    }
    else {
        return false;
    }
}
  
// Function to remove the
// vowels in the new Binary tree
Node* removevowels(Node* root)
{
    queue<Node*> Q;
    Q.push(root);
    // Declaring the root of
    // the new tree
    Node* root1 = NULL;
  
    while (!Q.empty()) {
        Node* temp = Q.front();
        Q.pop();
        // If the given character
        // is not a vowel, add it
        // to the new Binary tree
        if (!checkvowel(temp->data)) {
            root1 = addinBT(root1, temp->data);
        }
        if (temp->left) {
            Q.push(temp->left);
        }
        if (temp->right) {
            Q.push(temp->right);
        }
    }
    return root1;
}
  
// Driver code
int main()
{
  
    string s = "geeks";
    Node* root = NULL;
  
    for (int i = 0; i < s.size(); i++) {
        root = addinBT(root, s[i]);
    }
  
    root = removevowels(root);
    print(root);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
  
class GFG 
{
  
    // Structure Representing
    // the Node in the Binary tree
    static class Node 
    {
        char data;
        Node left, right;
  
        Node(char _val) 
        {
            data = _val;
            left = right = null;
        }
    };
  
    // Function to perform a level
    // order insertion of a new Node
    // in the Binary tree
    static Node addinBT(Node root, 
                        char data)
    {
        // If the root is empty,
        // make it point to the new Node
        if (root == null
        {
            root = new Node(data);
        
        else 
        {
  
            // In case there are elements
            // in the Binary tree, perform
            // a level order traversal
            // using a Queue
            Queue<Node> Q = new LinkedList<Node>();
            Q.add(root);
  
            while (!Q.isEmpty()) 
            {
                Node temp = Q.peek();
                Q.remove();
                  
                // If the left child does
                // not exist, insert the
                // new Node as the left child
                if (temp.left == null
                {
                    temp.left = new Node(data);
                    break;
                
                else
                    Q.add(temp.left);
                      
                // In case the right child
                // does not exist, insert
                // the new Node as the right child
                if (temp.right == null
                {
                    temp.right = new Node(data);
                    break;
                
                else
                    Q.add(temp.right);
            }
        }
        return root;
    }
  
    // Function to print the level
    // order traversal of the Binary tree
    static void print(Node root) 
    {
        Queue<Node> Q = new LinkedList<Node>();
        Q.add(root);
  
        while (Q.size() > 0)
        {
            Node temp = Q.peek();
            Q.remove();
            System.out.print(temp.data);
            if (temp.left != null)
                Q.add(temp.left);
            if (temp.right != null)
                Q.add(temp.right);
        }
    }
  
    // Function to check if the
    // character is a vowel or not.
    static boolean checkvowel(char ch)
    {
        ch = Character.toLowerCase(ch);
        if (ch == 'a' || ch == 'e' || 
            ch == 'i' || ch == 'o' || 
            ch == 'u')
        {
            return true;
        
        else 
        {
            return false;
        }
    }
  
    // Function to remove the
    // vowels in the new Binary tree
    static Node removevowels(Node root)
    {
        Queue<Node> Q = new LinkedList<Node>();
        Q.add(root);
          
        // Declaring the root of
        // the new tree
        Node root1 = null;
  
        while (!Q.isEmpty())
        {
            Node temp = Q.peek();
            Q.remove();
              
            // If the given character
            // is not a vowel, add it
            // to the new Binary tree
            if (!checkvowel(temp.data)) 
            {
                root1 = addinBT(root1, temp.data);
            }
            if (temp.left != null)
            {
                Q.add(temp.left);
            }
            if (temp.right != null
            {
                Q.add(temp.right);
            }
        }
        return root1;
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        String s = "geeks";
        Node root = null;
  
        for (int i = 0; i < s.length(); i++)
        {
            root = addinBT(root, s.charAt(i));
        }
  
        root = removevowels(root);
        print(root);
    }
}
  
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program
# for the above approach
  
# Structure Representing
# the Node in the Binary tree
class Node: 
    def __init__( self,_val):
        self.data = _val
        self.left = self.right = None
      
# Function to perform a level
# order insertion of a Node
# in the Binary tree
def addinBT(root, data):
  
    # If the root is empty,
    # make it point to the Node
    if (root == None) :
        root = Node(data)
      
    else :
  
        # In case there are elements
        # in the Binary tree, perform
        # a level order traversal
        # using a Queue
        Q = []
        Q.append(root)
  
        while (len(Q) > 0): 
            temp = Q[-1]
            Q.pop()
              
            # If the left child does
            # not exist, insert the
            # Node as the left child
            if (temp.left == None) :
                temp.left = Node(data)
                break
              
            else:
                Q.append(temp.left)
                  
            # In case the right child
            # does not exist, insert
            # the Node as the right child
            if (temp.right == None): 
                temp.right = Node(data)
                break
              
            else:
                Q.append(temp.right)
          
    return root
  
# Function to print the level
# order traversal of the Binary tree
def print_(root):
  
    Q = [] 
    Q.append(root)
  
    while (len(Q) > 0) :
        temp = Q[-1]
        Q.pop()
        print(temp.data,end = " ")
        if (temp.left != None):
            Q.append(temp.left)
        if (temp.right != None):
            Q.append(temp.right)
      
# Function to check if the
# character is a vowel or not.
def checkvowel( ch):
  
    ch = ch.lower()
    if (ch == 'a' or ch == 'e' or ch == 'i'
                or ch == 'o' or ch == 'u'): 
        return True
      
    else
        return False
  
# Function to remove the
# vowels in the Binary tree
def removevowels(root):
  
    Q = []
    Q.append(root)
  
    # Declaring the root of
    # the tree
    root1 = None
  
    while (len(Q) > 0): 
        temp = Q[-1]
        Q.pop()
  
        # If the given character
        # is not a vowel, add it
        # to the Binary tree
        if (not checkvowel(temp.data)) :
            root1 = addinBT(root1, temp.data)
          
        if (temp.left != None): 
            Q.append(temp.left)
          
        if (temp.right != None): 
            Q.append(temp.right)
          
    return root1
  
# Driver code
s = "geeks"
root = None
  
for i in range( len(s) ) :
    root = addinBT(root, s[i])
      
root = removevowels(root)
print_(root)
  
# This code is contributed by Arnab Kundu

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
  
class GFG 
{
  
    // Structure Representing
    // the Node in the Binary tree
    class Node 
    {
        public char data;
        public Node left, right;
  
        public Node(char _val) 
        {
            data = _val;
            left = right = null;
        }
    };
  
    // Function to perform a level
    // order insertion of a new Node
    // in the Binary tree
    static Node addinBT(Node root, 
                        char data)
    {
        // If the root is empty,
        // make it point to the new Node
        if (root == null
        {
            root = new Node(data);
        
        else
        {
  
            // In case there are elements
            // in the Binary tree, perform
            // a level order traversal
            // using a Queue
            List<Node> Q = new List<Node>();
            Q.Add(root);
  
            while (Q.Count != 0) 
            {
                Node temp = Q[0];
                Q.RemoveAt(0);
                  
                // If the left child does
                // not exist, insert the
                // new Node as the left child
                if (temp.left == null
                {
                    temp.left = new Node(data);
                    break;
                
                else
                    Q.Add(temp.left);
                      
                // In case the right child
                // does not exist, insert
                // the new Node as the right child
                if (temp.right == null
                {
                    temp.right = new Node(data);
                    break;
                
                else
                    Q.Add(temp.right);
            }
        }
        return root;
    }
  
    // Function to print the level
    // order traversal of the Binary tree
    static void print(Node root) 
    {
        List<Node> Q = new List<Node>();
        Q.Add(root);
  
        while (Q.Count > 0)
        {
            Node temp = Q[0];
            Q.RemoveAt(0);
            Console.Write(temp.data);
            if (temp.left != null)
                Q.Add(temp.left);
            if (temp.right != null)
                Q.Add(temp.right);
        }
    }
  
    // Function to check if the
    // character is a vowel or not.
    static bool checkvowel(char ch)
    {
        ch = char.ToLower(ch);
        if (ch == 'a' || ch == 'e' || 
            ch == 'i' || ch == 'o' || 
            ch == 'u')
        {
            return true;
        
        else
        {
            return false;
        }
    }
  
    // Function to remove the
    // vowels in the new Binary tree
    static Node removevowels(Node root)
    {
        List<Node> Q = new List<Node>();
        Q.Add(root);
          
        // Declaring the root of
        // the new tree
        Node root1 = null;
  
        while (Q.Count != 0)
        {
            Node temp = Q[0];
            Q.RemoveAt(0);
              
            // If the given character
            // is not a vowel, add it
            // to the new Binary tree
            if (!checkvowel(temp.data)) 
            {
                root1 = addinBT(root1, temp.data);
            }
            if (temp.left != null)
            {
                Q.Add(temp.left);
            }
            if (temp.right != null
            {
                Q.Add(temp.right);
            }
        }
        return root1;
    }
  
    // Driver code
    public static void Main(String[] args) 
    {
        String s = "geeks";
        Node root = null;
  
        for (int i = 0; i < s.Length; i++)
        {
            root = addinBT(root, s[i]);
        }
  
        root = removevowels(root);
        print(root);
    }
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

gks

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :