Print all even nodes of Binary Search Tree
Last Updated :
06 Sep, 2022
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++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int key;
struct Node *left, *right;
};
Node* newNode( int item)
{
Node* temp = new Node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
void inorder(Node* root)
{
if (root != NULL) {
inorder(root->left);
cout << root->key << " " ;
inorder(root->right);
}
}
Node* insert(Node* node, int key)
{
if (node == NULL)
return newNode(key);
if (key < node->key)
node->left = insert(node->left, key);
else
node->right = insert(node->right, key);
return node;
}
void evenNode(Node* root)
{
if (root != NULL) {
evenNode(root->left);
if (root->key % 2 == 0)
cout << root->key << " " ;
evenNode(root->right);
}
}
int main()
{
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
class GfG {
static class Node {
int key;
Node left, right;
}
static Node newNode( int item)
{
Node temp = new Node();
temp.key = item;
temp.left = null ;
temp.right = null ;
return temp;
}
static void inorder(Node root)
{
if (root != null ) {
inorder(root.left);
System.out.print(root.key + " " );
inorder(root.right);
}
}
static Node insert(Node node, int key)
{
if (node == null )
return newNode(key);
if (key < node.key)
node.left = insert(node.left, key);
else
node.right = insert(node.right, key);
return node;
}
static void evenNode(Node root)
{
if (root != null ) {
evenNode(root.left);
if (root.key % 2 == 0 )
System.out.print(root.key + " " );
evenNode(root.right);
}
}
public static void main(String[] args)
{
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
class newNode:
def __init__( self , key):
self .key = key
self .left = None
self .right = None
def inorder(root) :
if (root ! = None ):
inorder(root.left)
printf( "%d " , root.key)
inorder(root.right)
def insert(node, key):
if (node = = None ):
return newNode(key)
if (key < node.key):
node.left = insert(node.left, key)
else :
node.right = insert(node.right, key)
return node
def evenNode(root) :
if (root ! = None ):
evenNode(root.left)
if (root.key % 2 = = 0 ):
print (root.key, end = " " )
evenNode(root.right)
if __name__ = = '__main__' :
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)
|
C#
using System;
class GfG
{
class Node
{
public int key;
public Node left, right;
}
static Node newNode( int item)
{
Node temp = new Node();
temp.key = item;
temp.left = null ;
temp.right = null ;
return temp;
}
static void inorder(Node root)
{
if (root != null )
{
inorder(root.left);
Console.Write(root.key + " " );
inorder(root.right);
}
}
static Node insert(Node node, int key)
{
if (node == null )
return newNode(key);
if (key < node.key)
node.left = insert(node.left, key);
else
node.right = insert(node.right, key);
return node;
}
static void evenNode(Node root)
{
if (root != null )
{
evenNode(root.left);
if (root.key % 2 == 0)
Console.Write(root.key + " " );
evenNode(root.right);
}
}
public static void Main(String[] args)
{
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);
}
}
|
Javascript
<script>
class Node {
constructor() {
this .key = 0;
this .left = null ;
this .right = null ;
}
}
function newNode(item)
{
var temp = new Node();
temp.key = item;
temp.left = null ;
temp.right = null ;
return temp;
}
function inorder(root)
{
if (root != null ) {
inorder(root.left);
document.write(root.key + " " );
inorder(root.right);
}
}
function insert(node , key)
{
if (node == null )
return newNode(key);
if (key < node.key)
node.left = insert(node.left, key);
else
node.right = insert(node.right, key);
return node;
}
function evenNode(root)
{
if (root != null ) {
evenNode(root.left);
if (root.key % 2 == 0)
document.write(root.key + " " );
evenNode(root.right);
}
}
var 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);
</script>
|
Complexity Analysis:
- Time Complexity: O(N)
- Here N is the number of nodes and as we have to visit every node the time complexity is O(N).
- Auxiliary Space: O(h)
- Here h is the height of the tree and extra space is used in recursion call stack.
Share your thoughts in the comments
Please Login to comment...