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 <bits/stdc++.h> 
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<Node*> 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

My Personal Notes

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

C/C++

Python

Recommended Posts: