# Sink even nodes in Binary Tree

Given a Binary Tree having odd and even elements, sink all it’s even valued nodes such that no node with even value could be a parent of a node with odd 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 odd nodes and all even nodes follows the rule)

Examples:

```Input:
1
/    \
5       8
/  \     /  \
2    4   9    10
Output:
1
5 9
2 4 8 10

Level order traversal after
sinking all the nodes

Input:
4
/  \
2    1
Output:
4
2 1
```
```Explanation:
In the first case
Given tree
4
/    \
2      1

There are two trees possible
1            1
/    \   OR   /   \
2      4      4     2

In the second example also,
Given tree
1
/    \
5       8
/  \     /  \
2    4   9    10

There are more than one tree
that can satisfy the condition
1                 1
/    \            /    \
5       9    OR   5      9
/  \    /  \      /  \   / \
2   4  8   10    4    2  8  10

```

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

Approach:

• Basically, it is required to swap the even value of a node with odd value of one of its descendants.
• The idea is to traverse the tree in postorder fashion.
• Since we process in postorder, for each even node encountered, it’s left and right subtrees are already balanced (sinked).
• Check if it’s an even node and its left or right child has an odd value. If odd value is found, swap the node’s data with that of odd child node and call the procedure on the odd child to balance the subtree.
• If both children have even values, that means that all its descendants are even.

Below is the implementation of the idea:

## C/C++

 `// Program to sink even nodes ` `// to the bottom of binary tree ` `#include ` `using` `namespace` `std; ` ` `  `// A binary tree node ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// Helper function to allocates ` `// a new node ` `Node* newnode(``int` `data) ` `{ ` `    ``Node* node = ``new` `Node; ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` `    ``return` `node; ` `} ` ` `  `// Helper function to check ` `// if node is leaf node ` `bool` `isLeaf(Node* root) ` `{ ` `    ``return` `(root->left == NULL ` `            ``&& root->right == NULL); ` `} ` ` `  `// A recursive method to sink ` `// a tree with odd root ` ` `  `// This method assumes that the ` `// subtrees are already sinked. ` `// This method is similar to ` `// Heapify of Heap-Sort ` `void` `sink(Node*& root) ` `{ ` `    ``// If NULL or is a leaf, do nothing ` `    ``if` `(root == NULL || isLeaf(root)) ` `        ``return``; ` ` `  `    ``// If left subtree exists ` `    ``// and left child is odd ` `    ``if` `(root->left ` `        ``&& (root->left->data & 1)) { ` ` `  `        ``// Swap root's data with left ` `        ``// child and fix left subtree ` `        ``swap(root->data, ` `             ``root->left->data); ` `        ``sink(root->left); ` `    ``} ` ` `  `    ``// If right subtree exists ` `    ``// and right child is odd ` `    ``else` `if` `(root->right ` `             ``&& (root->right->data & 1)) { ` ` `  `        ``// Swap root's data with right ` `        ``// child and fix right subtree ` `        ``swap(root->data, ` `             ``root->right->data); ` `        ``sink(root->right); ` `    ``} ` `} ` ` `  `// Function to sink all even ` `// nodes to the bottom of ` `// binary tree. It does a ` `// postorder traversal and ` `// calls sink() ` `// if any even node is found ` `void` `sinkevenNodes(Node*& root) ` `{ ` `    ``// If NULL or is a ` `    ``// leaf, do nothing ` `    ``if` `(root == NULL || isLeaf(root)) ` `        ``return``; ` ` `  `    ``// Process left and right ` `    ``// subtrees before this node ` `    ``sinkevenNodes(root->left); ` `    ``sinkevenNodes(root->right); ` ` `  `    ``// If root is even, sink it ` `    ``if` `(!(root->data & 1)) ` `        ``sink(root); ` `} ` ` `  `// Helper function to do Level ` `// Order Traversal of Binary Tree ` `// level by level. This function ` `// is used here only for showing ` `// modified tree. ` `void` `printLevelOrder(Node* root) ` `{ ` `    ``queue q; ` `    ``q.push(root); ` ` `  `    ``// Do Level order traversal ` `    ``while` `(!q.empty()) { ` `        ``int` `nodeCount = q.size(); ` ` `  `        ``// Print one level at a time ` `        ``while` `(nodeCount) { ` ` `  `            ``Node* node = q.front(); ` ` `  `            ``printf``(``"%d "``, node->data); ` ` `  `            ``q.pop(); ` ` `  `            ``// If the node has a left ` `            ``// child then push into queue ` `            ``if` `(node->left != NULL) ` `                ``q.push(node->left); ` ` `  `            ``// If the node has a right ` `            ``// child then push into queue ` `            ``if` `(node->right != NULL) ` `                ``q.push(node->right); ` ` `  `            ``nodeCount--; ` `        ``} ` ` `  `        ``// Line separator for levels ` `        ``printf``(``"\n"``); ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``/* Constructed binary tree is  ` `        ``1  ` `      ``/  \  ` `     ``5    8  ` `    ``/ \  / \  ` `   ``2  4 9  10     */` ` `  `    ``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); ` ` `  `    ``// Calling function to perform ` `    ``// sink operation ` `    ``sinkevenNodes(root); ` ` `  `    ``// Printing the updated tree ` `    ``// using level oerder traversal ` `    ``printLevelOrder(root); ` ` `  `    ``return` `0; ` `} `

## Python

 `# Python3 program to sink even nodes  ` `# to the bottom of binary tree  ` ` `  `# A binary tree node  ` `# Helper function to allocates a new node  ` `class` `newnode:  ` ` `  `    ``# Constructor to create a new node  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Helper function to check  ` `# if node is leaf node  ` `def` `isLeaf(root):  ` `    ``return` `(root.left ``=``=` `None` `and` `            ``root.right ``=``=` `None``)  ` ` `  `# A recursive method to sink a tree with even root  ` `# This method assumes that the subtrees are  ` `# already sinked. This method is similar to  ` `# Heapify of Heap-Sort  ` `def` `sink(root):  ` `     `  `    ``# If None or is a leaf, do nothing  ` `    ``if` `(root ``=``=` `None` `or` `isLeaf(root)):  ` `        ``return` `     `  `    ``# if left subtree exists and  ` `    ``# left child is even  ` `    ``if` `(root.left ``and` `(root.left.data & ``1``)):  ` `         `  `        ``# swap root's data with left child  ` `        ``# and fix left subtree  ` `        ``root.data, root.left.data ``=` `root.left.data, root.data  ` `        ``sink(root.left)  ` `         `  `    ``# if right subtree exists and  ` `    ``# right child is even  ` `    ``elif``(root.right ``and` `(root.right.data & ``1``)):  ` `         `  `        ``# swap root's data with right child  ` `        ``# and fix right subtree  ` `        ``root.data, root.right.data ``=` `root.right.data, root.data  ` `        ``sink(root.right)  ` ` `  `# Function to sink all even nodes to  ` `# the bottom of binary tree. It does  ` `# a postorder traversal and calls sink()  ` `# if any even node is found  ` `def` `sinkevenNodes(root):  ` `     `  `    ``# If None or is a leaf, do nothing  ` `    ``if` `(root ``=``=` `None` `or` `isLeaf(root)):  ` `        ``return` `         `  `    ``# Process left and right subtrees  ` `    ``# before this node  ` `    ``sinkevenNodes(root.left)  ` `    ``sinkevenNodes(root.right)  ` `     `  `    ``# If root is even, sink it  ` `    ``if` `not` `(root.data & ``1``):  ` `        ``sink(root)  ` ` `  `# Helper function to do Level Order Traversal  ` `# of Binary Tree level by level. This function  ` `# is used here only for showing modified tree.  ` `def` `printLevelOrder(root):  ` `    ``q ``=` `[]  ` `    ``q.append(root)  ` `     `  `    ``# Do Level order traversal  ` `    ``while` `(``len``(q)):  ` `         `  `        ``nodeCount ``=` `len``(q)  ` `         `  `        ``# Print one level at a time  ` `        ``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` `         `  `        ``# Line separator for levels  ` `        ``print``()  ` ` `  `# Driver Code  ` `""" Constructed binary tree is  ` `            ``1  ` `        ``/ \  ` `        ``5 8  ` `        ``/ \ / \  ` `    ``2 4 9 10     """` `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``)  ` ` `  `sinkevenNodes(root)  ` ` `  `printLevelOrder(root)  ` ` `  `# This code is contributed by SHUBHAMSINGH10  `

Output:

```1
5 9
2 4 8 10
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHUBHAMSINGH10

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.