Print all odd nodes of Binary Search Tree
Last Updated :
23 Jan, 2023
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 current node’s value is odd. 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);
printf ( "%d " , 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 oddNode(Node* root)
{
if (root != NULL) {
oddNode(root->left);
if (root->key % 2 != 0)
printf ( "%d " , root->key);
oddNode(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);
oddNode(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 oddNode(Node root)
{
if (root != null ) {
oddNode(root.left);
if (root.key % 2 != 0 )
System.out.print(root.key + " " );
oddNode(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 );
oddNode(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)
print (root.key, end = " " )
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 oddNode(root) :
if (root ! = None ):
oddNode(root.left)
if (root.key % 2 ! = 0 ):
print (root.key, end = " " )
oddNode(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 )
oddNode(root)
|
C#
using System;
public 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 oddNode(Node root)
{
if (root != null )
{
oddNode(root.left);
if (root.key % 2 != 0)
Console.Write(root.key + " " );
oddNode(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);
oddNode(root);
}
}
|
Javascript
<script>
class Node {
constructor(){
this .key = 0;
this .left = 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 oddNode(root) {
if (root != null ) {
oddNode(root.left);
if (root.key % 2 != 0)
document.write(root.key + " " );
oddNode(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);
oddNode(root);
</script>
|
Complexity Analysis:
- Time Complexity: O(n) where n is no. of nodes in the binary search tree.
- 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...