Remove vowels from a string stored in a Binary Tree

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.



Improved By : 29AjayKumar, andrew1234