Print all even nodes of Binary Search Tree

Given a binary search tree. The task is to print all even nodes of the binary search tree.

Examples:

Input : 
          5 
        /   \ 
       3     7 
      / \   / \ 
     2   4 6   8 
Output : 2 4 6 8

Input :
          14 
        /   \ 
       12    17 
      / \   / \ 
     8  13 16   19 
Output : 8 12 14 16

Approach: Traverse the Binary Search tree and check if current node’s value is even. If yes then print it otherwise skip that node.

Below is the implementation of the above Approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print all even node of BST
#include <bits/stdc++.h>
using namespace std;
  
// create Tree
struct Node {
    int key;
    struct Node *left, *right;
};
  
// A utility function to create a new BST node
Node* newNode(int item)
{
    Node* temp = new Node;
    temp->key = item;
    temp->left = temp->right = NULL;
    return temp;
}
  
// A utility function to do inorder traversal of BST
void inorder(Node* root)
{
    if (root != NULL) {
        inorder(root->left);
        printf(root->key,end=" ");
        inorder(root->right);
    }
}
  
/* A utility function to insert a new node
   with given key in BST */
Node* insert(Node* node, int key)
{
    /* If the tree is empty, return a new node */
    if (node == NULL)
        return newNode(key);
  
    /* Otherwise, recur down the tree */
    if (key < node->key)
        node->left = insert(node->left, key);
    else
        node->right = insert(node->right, key);
  
    /* return the (unchanged) node pointer */
    return node;
}
  
// Function to print all even nodes
void evenNode(Node* root)
{
    if (root != NULL) {
        evenNode(root->left);
        // if node is even then print it
        if (root->key % 2 == 0)
            printf("%d ", root->key);
        evenNode(root->right);
    }
}
  
// Driver Code
int main()
{
    /* Let us create following BST 
       
      / \ 
     3     7 
    / \ / \ 
    2 4 6 8 */
    Node* root = NULL;
    root = insert(root, 5);
    root = insert(root, 3);
    root = insert(root, 2);
    root = insert(root, 4);
    root = insert(root, 7);
    root = insert(root, 6);
    root = insert(root, 8);
  
    evenNode(root);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print all even node of BST 
class GfG { 
  
// create Tree 
static class Node { 
    int key; 
    Node left, right; 
}
  
// A utility function to create a new BST node 
static Node newNode(int item) 
    Node temp = new Node(); 
    temp.key = item; 
    temp.left = null;
    temp.right = null
    return temp; 
  
// A utility function to do inorder traversal of BST 
static void inorder(Node root) 
    if (root != null) { 
        inorder(root.left); 
        System.out.print(root.key + " "); 
        inorder(root.right); 
    
  
/* A utility function to insert a new node 
with given key in BST */
static Node insert(Node node, int key) 
    /* If the tree is empty, return a new node */
    if (node == null
        return newNode(key); 
  
    /* Otherwise, recur down the tree */
    if (key < node.key) 
        node.left = insert(node.left, key); 
    else
        node.right = insert(node.right, key); 
  
    /* return the (unchanged) node pointer */
    return node; 
  
// Function to print all even nodes 
static void evenNode(Node root) 
    if (root != null) { 
        evenNode(root.left); 
        // if node is even then print it 
        if (root.key % 2 == 0
            System.out.print(root.key + " "); 
        evenNode(root.right); 
    
  
// Driver Code 
public static void main(String[] args) 
    /* Let us create following BST 
    
    / \ 
    3     7 
    / \ / \ 
    2 4 6 8 */
    Node root = null
    root = insert(root, 5); 
    root = insert(root, 3); 
    root = insert(root, 2); 
    root = insert(root, 4); 
    root = insert(root, 7); 
    root = insert(root, 6); 
    root = insert(root, 8); 
  
    evenNode(root); 
  
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print all even node of BST 
  
# create Tree 
# to create a new BST node 
class newNode: 
  
    # Construct to create a new node 
    def __init__(self, key): 
        self.key = key
        self.left = None
        self.right = None
  
# A utility function to do inorder 
# traversal of BST 
def inorder(root) :
  
    if (root != None): 
        inorder(root.left) 
        printf("%d ", root.key) 
        inorder(root.right) 
      
""" A utility function to insert a new 
node with given key in BST """
def insert(node, key): 
  
    """ If the tree is empty,
    return a new node """
    if (node == None): 
        return newNode(key) 
  
    """ Otherwise, recur down the tree """
    if (key < node.key): 
        node.left = insert(node.left, key) 
    else:
        node.right = insert(node.right, key) 
  
    """ return the (unchanged) 
        node pointer """
    return node 
  
# Function to print all even nodes 
def evenNode(root) :
  
    if (root != None): 
        evenNode(root.left) 
          
        # if node is even then print it 
        if (root.key % 2 == 0):
            print(root.key, end = " "
        evenNode(root.right) 
  
# Driver Code 
if __name__ == '__main__':
      
    """ Let us create following BST 
    
    / \ 
    3 7 
    / \ / \ 
    2 4 6 8 """
    root = None
    root = insert(root, 5
    root = insert(root, 3
    root = insert(root, 2
    root = insert(root, 4
    root = insert(root, 7
    root = insert(root, 6
    root = insert(root, 8
  
    evenNode(root) 
  
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print all even node of BST 
using System;
  
class GfG 
  
    // create Tree 
    class Node 
    
        public int key; 
        public Node left, right; 
    
  
    // A utility function to 
    // create a new BST node 
    static Node newNode(int item) 
    
        Node temp = new Node(); 
        temp.key = item; 
        temp.left = null
        temp.right = null
        return temp; 
    
  
    // A utility function to do
    // inorder traversal of BST 
    static void inorder(Node root) 
    
        if (root != null
        
            inorder(root.left); 
            Console.Write(root.key + " "); 
            inorder(root.right); 
        
    
  
    /* A utility function to insert a new node 
    with given key in BST */
    static Node insert(Node node, int key) 
    
        /* If the tree is empty, return a new node */
        if (node == null
            return newNode(key); 
  
        /* Otherwise, recur down the tree */
        if (key < node.key) 
            node.left = insert(node.left, key); 
        else
            node.right = insert(node.right, key); 
  
        /* return the (unchanged) node pointer */
        return node; 
    
  
    // Function to print all even nodes 
    static void evenNode(Node root) 
    
        if (root != null)
        
            evenNode(root.left); 
              
            // if node is even then print it 
            if (root.key % 2 == 0) 
                Console.Write(root.key + " "); 
            evenNode(root.right); 
        
    
  
    // Driver Code 
    public static void Main(String[] args) 
    
        /* Let us create following BST 
        
        / \ 
        3 7 
        / \ / \ 
        2 4 6 8 */
        Node root = null
        root = insert(root, 5); 
        root = insert(root, 3); 
        root = insert(root, 2); 
        root = insert(root, 4); 
        root = insert(root, 7); 
        root = insert(root, 6); 
        root = insert(root, 8); 
  
        evenNode(root); 
    
  
// This code has been contributed 
// by PrinciRaj1992

chevron_right


Output:

2 4 6 8

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 Posts: