Sink Odd nodes in Binary Tree
Last Updated :
26 Feb, 2023
Given a Binary Tree having odd and even elements, sink all its odd valued nodes such that no node with odd value could be parent of node with even value. There can be multiple outputs for a given tree, we need to print one of them. It is always possible to convert a tree (Note that a node with even nodes and all odd nodes follows the rule)
Input :
1
/ \
2 3
Output
2 2
/ \ OR / \
1 3 3 1
Input :
1
/ \
5 8
/ \ / \
2 4 9 10
Output :
2 4
/ \ / \
4 8 OR 2 8 OR .. (any tree with
/ \ / \ / \ / \ same keys and
5 1 9 10 5 1 9 10 no odd is parent
of even)
We strongly recommend you to minimize your browser and try this yourself first.
Basically, we need to swap odd value of a node with even value of one of its descendants. The idea is to traverse the tree in a postorder fashion. Since we process in postorder, for each odd node encountered, its left and right subtrees are already balanced (sinked), we check if it’s an odd node and its left or right child has an even value. If even value is found, we swap the node’s data with that of even child node and call the procedure on the even child to balance the subtree. If both children have odd values, that means that all its descendants are odd.
Below is the implementation of the idea.
Implementation:
C++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
Node* left, *right;
};
Node* newnode( int data)
{
Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return node;
}
bool isLeaf(Node *root)
{
return (root->left == NULL && root->right == NULL);
}
void sink(Node *&root)
{
if (root == NULL || isLeaf(root))
return ;
if (root->left && !(root->left->data & 1))
{
swap(root->data, root->left->data);
sink(root->left);
}
else if (root->right && !(root->right->data & 1))
{
swap(root->data, root->right->data);
sink(root->right);
}
}
void sinkOddNodes(Node* &root)
{
if (root == NULL || isLeaf(root))
return ;
sinkOddNodes(root->left);
sinkOddNodes(root->right);
if (root->data & 1)
sink(root);
}
void printLevelOrder(Node* root)
{
queue<Node*> q;
q.push(root);
while (!q.empty())
{
int nodeCount = q.size();
while (nodeCount)
{
Node *node = q.front();
printf ( "%d " , node->data);
q.pop();
if (node->left != NULL)
q.push(node->left);
if (node->right != NULL)
q.push(node->right);
nodeCount--;
}
printf ( "\n" );
}
}
int main()
{
Node *root = newnode(1);
root->left = newnode(5);
root->right = newnode(8);
root->left->left = newnode(2);
root->left->right = newnode(4);
root->right->left = newnode(9);
root->right->right = newnode(10);
sinkOddNodes(root);
printf ( "Level order traversal of modified tree\n" );
printLevelOrder(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
};
static Node newnode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static boolean isLeaf(Node root)
{
if (root== null ){
return false ;
}
return (root.left == null && root.right == null )? true : false ;
}
static void sink(Node root)
{
if (root == null || isLeaf( null ))
return ;
if (root.left!= null && (root.left.data & 1 )== 0 )
{
int temp = root.data;
root.data=root.left.data;
root.left.data=temp;
sink(root.left);
}
else if (root.right!= null && (root.right.data & 1 )== 0 )
{
int temp = root.data;
root.data=root.right.data;
root.right.data=temp;
sink(root.right);
}
}
static void sinkOddNodes(Node root)
{
if (root == null || isLeaf(root))
return ;
sinkOddNodes(root.left);
sinkOddNodes(root.right);
if ((root.data & 1 )!= 0 )
sink(root);
}
static void printLevelOrder(Node root)
{
Queue<Node> q = new LinkedList<>();
q.add(root);
while (!q.isEmpty())
{
int nodeCount = q.size();
while (nodeCount> 0 )
{
Node node = q.poll();
System.out.print(node.data+ " " );
if (node.left != null )
q.add(node.left);
if (node.right != null )
q.add(node.right);
nodeCount--;
}
System.out.println( "" );
}
}
public static void main(String[] args)
{
Node root = newnode( 1 );
root.left = newnode( 5 );
root.right = newnode( 8 );
root.left.left = newnode( 2 );
root.left.right = newnode( 4 );
root.right.left = newnode( 9 );
root.right.right = newnode( 10 );
sinkOddNodes(root);
System.out.print( "Level order traversal of modified tree\n" );
printLevelOrder(root);
}
}
|
Python3
class newnode:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
def isLeaf(root):
return (root.left = = None and
root.right = = None )
def sink(root):
if (root = = None or isLeaf(root)):
return
if (root.left and not (root.left.data & 1 )):
root.data, \
root.left.data = root.left.data, \
root.data
sink(root.left)
else if (root.right and not (root.right.data & 1 )):
root.data, \
root.right.data = root.right.data, \
root.data
sink(root.right)
def sinkOddNodes(root):
if (root = = None or isLeaf(root)):
return
sinkOddNodes(root.left)
sinkOddNodes(root.right)
if (root.data & 1 ):
sink(root)
def printLevelOrder(root):
q = []
q.append(root)
while ( len (q)):
nodeCount = len (q)
while (nodeCount):
node = q[ 0 ]
print (node.data, end = " " )
q.pop( 0 )
if (node.left ! = None ):
q.append(node.left)
if (node.right ! = None ):
q.append(node.right)
nodeCount - = 1
print ()
root = newnode( 1 )
root.left = newnode( 5 )
root.right = newnode( 8 )
root.left.left = newnode( 2 )
root.left.right = newnode( 4 )
root.right.left = newnode( 9 )
root.right.right = newnode( 10 )
sinkOddNodes(root)
print ( "Level order traversal of modified tree" )
printLevelOrder(root)
|
C#
using System;
using System.Collections.Generic;
class GFG {
class Node {
public int data;
public Node left, right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static bool isLeaf(Node root)
{
if (root == null ) {
return false ;
}
return (root.left == null && root.right == null )
? true
: false ;
}
static void sink(Node root)
{
if (root == null || isLeaf( null ))
return ;
if (root.left != null
&& (root.left.data & 1) == 0) {
int temp = root.data;
root.data = root.left.data;
root.left.data = temp;
sink(root.left);
}
else if (root.right != null
&& (root.right.data & 1) == 0) {
int temp = root.data;
root.data = root.right.data;
root.right.data = temp;
sink(root.right);
}
}
static void sinkOddNodes(Node root)
{
if (root == null || isLeaf(root))
return ;
sinkOddNodes(root.left);
sinkOddNodes(root.right);
if ((root.data & 1) != 0)
sink(root);
}
static void printLevelOrder(Node root)
{
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count != 0) {
int nodeCount = q.Count;
while (nodeCount > 0) {
Node node = q.Dequeue();
Console.Write(node.data + " " );
if (node.left != null )
q.Enqueue(node.left);
if (node.right != null )
q.Enqueue(node.right);
nodeCount--;
}
Console.WriteLine( "" );
}
}
static void Main( string [] args)
{
Node root = newNode(1);
root.left = newNode(5);
root.right = newNode(8);
root.left.left = newNode(2);
root.left.right = newNode(4);
root.right.left = newNode(9);
root.right.right = newNode(10);
sinkOddNodes(root);
Console.WriteLine(
"Level order traversal of modified tree" );
printLevelOrder(root);
}
}
|
Javascript
<script>
class Node {
constructor(data) {
this .data = data;
this .left = null ;
this .right = null ;
}
}
function isLeaf(root) {
return (root.left === null && root.right === null );
}
function sink(root) {
if (root === null || isLeaf(root)) {
return ;
}
if (root.left && !(root.left.data & 1)) {
[root.data, root.left.data] = [root.left.data, root.data];
sink(root.left);
}
else if (root.right && !(root.right.data & 1)) {
[root.data, root.right.data] = [root.right.data, root.data];
sink(root.right);
}
}
function sinkOddNodes(root) {
if (root === null || isLeaf(root)) {
return ;
}
sinkOddNodes(root.left);
sinkOddNodes(root.right);
if (root.data & 1) {
sink(root);
}
}
function printLevelOrder(root) {
let q = [];
q.push(root);
while (q.length) {
let nodeCount = q.length;
while (nodeCount) {
let node = q[0];
document.write(node.data+ " " );
q.shift();
if (node.left !== null ) {
q.push(node.left);
}
if (node.right !== null ) {
q.push(node.right);
}
nodeCount -= 1;
}
document.write( "<br>" )
}
}
let root = new Node(1);
root.left = new Node(5);
root.right = new Node(8);
root.left.left = new Node(2);
root.left.right = new Node(4);
root.right.left = new Node(9);
root.right.right = new Node(10);
sinkOddNodes(root);
document.write( "Level order traversal of modified tree" );
document.write( "<br>" )
printLevelOrder(root);
</script>
|
Output
Level order traversal of modified tree
2
4 8
5 1 9 10
Time Complexity:O(N), where N is total number of nodes in binary tree.
Space Complexity: O(N), where N is total number of nodes in binary tree
Share your thoughts in the comments
Please Login to comment...