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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++

// 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  
       5  
      / \  
     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; 
} 

Java

// 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  
    5  
    / \  
    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);  
  
} 
}  

Python3

# 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  
    5  
    / \  
    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) 

C#

// 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  
        5  
        / \  
        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 

Output:

2 4 6 8

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: