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++
// 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);
cout << root->key << " ";
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)
cout << 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 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 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# 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
<script>
// JavaScript program to print all even node of BST
// create Tree
class Node {
constructor() {
this.key = 0;
this.left = null;
this.right = null;
}
}
// A utility function to create a new BST node
function newNode(item)
{
var temp = new Node();
temp.key = item;
temp.left = null;
temp.right = null;
return temp;
}
// A utility function to do inorder traversal of BST
function inorder(root)
{
if (root != null) {
inorder(root.left);
document.write(root.key + " ");
inorder(root.right);
}
}
/* A utility function to insert a new node
with given key in BST */
function insert(node , 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
function evenNode(root)
{
if (root != null) {
evenNode(root.left);
// if node is even then print it
if (root.key % 2 == 0)
document.write(root.key + " ");
evenNode(root.right);
}
}
// Driver Code
/* Let us create following BST
5
/ \
3 7
/ \ / \
2 4 6 8 */
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);
// This code contributed by aashish1995
</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.
Similar Reads
Print all odd nodes of Binary Search Tree Given a binary search tree. The task is to print all odd nodes of the binary search tree. Examples: Input : 5 / \ 3 7 / \ / \ 2 4 6 8 Output : 3 5 7 Input : 14 / \ 12 17 / \ / \ 8 13 16 19 Output : 13 17 19 Approach: Traverse the Binary Search tree using any of the tree traversals and check if the c
8 min read
Print Levels of all nodes in a Binary Tree Given a Binary Tree and a key, write a function that prints levels of all keys in given binary tree. For example, consider the following tree. If the input key is 3, then your function should return 1. If the input key is 4, then your function should return 3. And for key which is not present in key
7 min read
Print all internal nodes of a Binary tree Given a Binary tree, the task is to print all the internal nodes in a tree. An internal node is a node which carries at least one child or in other words, an internal node is not a leaf node. Here we intend to print all such internal nodes in level order. Consider the following Binary Tree: Input: O
7 min read
Leaf nodes from Preorder of a Binary Search Tree Given Preorder traversal of a Binary Search Tree. Then the task is to print leaf nodes of the Binary Search Tree from the given preorder.Examples: Input: preorder[] = [4, 2, 1, 3, 6, 5]Output: [1, 3, 5]Explaination: 1, 3 and 5 are the leaf nodes as shown in the figure. Input: preorder[] = [5, 2, 10]
14 min read
Find all even sum paths in given Binary Search Tree Given a Binary search tree having N nodes, the task is to find all the paths starting at the root and ending at any leaf and having an even sum. Examples: Input: Img-Btree Output:Even sum Paths are:1st) 1 -> 19 -> 4 -> 9 -> 7 = sum(40) 2nd) 1 -> 19 -> 4 -> 9 -> 13 -> 18 -
9 min read