A tree is a Continuous tree if in each root to leaf path, the absolute difference between keys of two adjacent is 1. We are given a binary tree, we need to check if the tree is continuous or not.
Examples:
Input : 3 / \ 2 4 / \ \ 1 3 5 Output: "Yes" // 3->2->1 every two adjacent node's absolute difference is 1 // 3->2->3 every two adjacent node's absolute difference is 1 // 3->4->5 every two adjacent node's absolute difference is 1 Input : 7 / \ 5 8 / \ \ 6 4 10 Output: "No" // 7->5->6 here absolute difference of 7 and 5 is not 1. // 7->5->4 here absolute difference of 7 and 5 is not 1. // 7->8->10 here absolute difference of 8 and 10 is not 1.
The solution requires a traversal of the tree. The important things to check are to make sure that all corner cases are handled. The corner cases include an empty tree, single-node tree, a node with only the left child and a node with the only right child.
In tree traversal, we recursively check if left and right subtree are continuous. We also check if the difference between the keys of the current node’s key and its children keys is 1. Below is the implementation of the idea.
Implementation:
// C++ program to check if a tree is continuous or not #include<bits/stdc++.h> using namespace std;
/* A binary tree node has data, pointer to left child and a pointer to right child */
struct Node
{ int data;
struct Node* left, * right;
}; /* Helper function that allocates a new node with the given data and NULL left and right pointers. */
struct Node* newNode( int data)
{ struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
} // Function to check tree is continuous or not bool treeContinuous( struct Node *ptr)
{ // if next node is empty then return true
if (ptr == NULL)
return true ;
// if current node is leaf node then return true
// because it is end of root to leaf path
if (ptr->left == NULL && ptr->right == NULL)
return true ;
// If left subtree is empty, then only check right
if (ptr->left == NULL)
return ( abs (ptr->data - ptr->right->data) == 1) &&
treeContinuous(ptr->right);
// If right subtree is empty, then only check left
if (ptr->right == NULL)
return ( abs (ptr->data - ptr->left->data) == 1) &&
treeContinuous(ptr->left);
// If both left and right subtrees are not empty, check
// everything
return abs (ptr->data - ptr->left->data)==1 &&
abs (ptr->data - ptr->right->data)==1 &&
treeContinuous(ptr->left) &&
treeContinuous(ptr->right);
} /* Driver program to test mirror() */ int main()
{ struct Node *root = newNode(3);
root->left = newNode(2);
root->right = newNode(4);
root->left->left = newNode(1);
root->left->right = newNode(3);
root->right->right = newNode(5);
treeContinuous(root)? cout << "Yes" : cout << "No" ;
return 0;
} |
// Java program to check if a tree is continuous or not import java.util.*;
class solution
{ /* A binary tree node has data, pointer to left child and a pointer to right child */ static class Node
{ int data;
Node left, right;
}; /* Helper function that allocates a new node with the given data and null left and right pointers. */ static Node newNode( int data)
{ Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
} // Function to check tree is continuous or not static boolean treeContinuous( Node ptr)
{ // if next node is empty then return true
if (ptr == null )
return true ;
// if current node is leaf node then return true
// because it is end of root to leaf path
if (ptr.left == null && ptr.right == null )
return true ;
// If left subtree is empty, then only check right
if (ptr.left == null )
return (Math.abs(ptr.data - ptr.right.data) == 1 ) &&
treeContinuous(ptr.right);
// If right subtree is empty, then only check left
if (ptr.right == null )
return (Math.abs(ptr.data - ptr.left.data) == 1 ) &&
treeContinuous(ptr.left);
// If both left and right subtrees are not empty, check
// everything
return Math.abs(ptr.data - ptr.left.data)== 1 &&
Math.abs(ptr.data - ptr.right.data)== 1 &&
treeContinuous(ptr.left) &&
treeContinuous(ptr.right);
} /* Driver program to test mirror() */ public static void main(String args[])
{ Node root = newNode( 3 );
root.left = newNode( 2 );
root.right = newNode( 4 );
root.left.left = newNode( 1 );
root.left.right = newNode( 3 );
root.right.right = newNode( 5 );
if (treeContinuous(root))
System.out.println( "Yes" ) ;
else
System.out.println( "No" );
} } //contributed by Arnab Kundu |
#Python Program to check continuous tree or not # A binary tree node has data, pointer to left child # an a pointer to right child */ # Helper function that allocates a new node with the # given data and null left and right pointers class newNode():
def __init__( self ,key) :
self .left = None
self .right = None
self .data = key
# Function to check tree is continuous or not def treeContinuous(root):
# if next node is empty then return true
if not root:
return True
# if current node is leaf node then return true
# because it is end of root to leaf path
if root.left:
if not abs (root.data - root.left.data) = = 1 :
return False
# If right subtree is empty, then only check left
if root.right:
if not abs (root.data - root.right.data) = = 1 :
return False
# If both left and right subtrees are not empty, check
# everything
if treeContinuous(root.left) and treeContinuous(root.right):
return True
# Driver code if __name__ = = '__main__' :
root = newNode( 7 )
root.left = newNode( 6 )
root.right = newNode( 8 )
root.left.left = newNode( 5 )
root.left.right = newNode( 7 )
root.right.right = newNode( 7 )
print (treeContinuous(root))
|
// C# program to check if a tree is continuous or not using System;
class solution
{ /* A binary tree node has data, pointer to left child and a pointer to right child */ class Node
{ public int data;
public Node left, right;
}; /* Helper function that allocates a new node with the given data and null left and right pointers. */ static Node newNode( int data)
{ Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
} // Function to check tree is continuous or not static Boolean treeContinuous( Node ptr)
{ // if next node is empty then return true
if (ptr == null )
return true ;
// if current node is leaf node then return true
// because it is end of root to leaf path
if (ptr.left == null && ptr.right == null )
return true ;
// If left subtree is empty, then only check right
if (ptr.left == null )
return (Math.Abs(ptr.data - ptr.right.data) == 1) &&
treeContinuous(ptr.right);
// If right subtree is empty, then only check left
if (ptr.right == null )
return (Math.Abs(ptr.data - ptr.left.data) == 1) &&
treeContinuous(ptr.left);
// If both left and right subtrees are not empty, check
// everything
return Math.Abs(ptr.data - ptr.left.data)==1 &&
Math.Abs(ptr.data - ptr.right.data)==1 &&
treeContinuous(ptr.left) &&
treeContinuous(ptr.right);
} /* Driver program to test mirror() */ static public void Main(String []args)
{ Node root = newNode(3);
root.left = newNode(2);
root.right = newNode(4);
root.left.left = newNode(1);
root.left.right = newNode(3);
root.right.right = newNode(5);
if (treeContinuous(root))
Console.WriteLine( "Yes" ) ;
else
Console.WriteLine( "No" );
} } //contributed by Arnab Kundu |
<script> // JavaScript program to check if a tree is continuous or not /* A binary tree node has data, pointer to left child and a pointer to right child */ class Node { constructor()
{
this .data=0;
this .left = null ;
this .right = null ;
}
}; /* Helper function that allocates a new node with the given data and null left and right pointers. */ function newNode(data)
{ var node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
} // Function to check tree is continuous or not function treeContinuous( ptr)
{ // if next node is empty then return true
if (ptr == null )
return true ;
// if current node is leaf node then return true
// because it is end of root to leaf path
if (ptr.left == null && ptr.right == null )
return true ;
// If left subtree is empty, then only check right
if (ptr.left == null )
return (Math.abs(ptr.data - ptr.right.data) == 1) &&
treeContinuous(ptr.right);
// If right subtree is empty, then only check left
if (ptr.right == null )
return (Math.abs(ptr.data - ptr.left.data) == 1) &&
treeContinuous(ptr.left);
// If both left and right subtrees are not empty, check
// everything
return Math.abs(ptr.data - ptr.left.data)==1 &&
Math.abs(ptr.data - ptr.right.data)==1 &&
treeContinuous(ptr.left) &&
treeContinuous(ptr.right);
} /* Driver program to test mirror() */ var root = newNode(3);
root.left = newNode(2); root.right = newNode(4); root.left.left = newNode(1); root.left.right = newNode(3); root.right.right = newNode(5); if (treeContinuous(root))
document.write( "Yes" ) ;
else document.write( "No" );
</script> |
Yes
Another approach (using BFS(Queue))
Explanation: We will simply traverse each node level by level and check if the difference between parent and child is 1, if it is true for all nodes then we will return true else we will return false.
Implementation:
// CPP Code to check if the tree is continuous or not #include <bits/stdc++.h> using namespace std;
// Node structure struct node {
int val;
node* left;
node* right;
node()
: val(0)
, left(nullptr)
, right(nullptr)
{
}
node( int x)
: val(x)
, left(nullptr)
, right(nullptr)
{
}
node( int x, node* left, node* right)
: val(x)
, left(left)
, right(right)
{
}
}; // Function to check if the tree is continuous or not bool continuous( struct node* root)
{ // If root is Null then tree isn't Continuous
if (root == NULL)
return false ;
int flag = 1;
queue< struct node*> Q;
Q.push(root);
node* temp;
// BFS Traversal
while (!Q.empty()) {
temp = Q.front();
Q.pop();
// Move to left child
if (temp->left) {
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if ( abs (temp->left->val - temp->val) == 1)
Q.push(temp->left);
else {
flag = 0;
break ;
}
}
// Move to right child
if (temp->right) {
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if ( abs (temp->right->val - temp->val) == 1)
Q.push(temp->right);
else {
flag = 0;
break ;
}
}
}
if (flag)
return true ;
else
return false ;
} // Driver Code int main()
{ // Constructing the Tree
struct node* root = new node(3);
root->left = new node(2);
root->right = new node(4);
root->left->left = new node(1);
root->left->right = new node(3);
root->right->right = new node(5);
// Function Call
if (continuous(root))
cout << "True\n" ;
else
cout << "False\n" ;
return 0;
} // This code is contributed by Sanjeev Yadav. |
// JAVA Code to check if the tree is continuous or not import java.util.*;
class GFG
{ // Node structure static class node
{ int val;
node left;
node right;
node()
{
this .val = 0 ;
this .left = null ;
this .right= null ;
}
node( int x)
{
this .val = x;
this .left = null ;
this .right= null ;
}
node( int x, node left, node right)
{
this .val = x;
this .left = left;
this .right= right;
}
}; // Function to check if the tree is continuous or not static boolean continuous(node root)
{ // If root is Null then tree isn't Continuous
if (root == null )
return false ;
int flag = 1 ;
Queue<node> Q = new LinkedList<>();
Q.add(root);
node temp;
// BFS Traversal
while (!Q.isEmpty())
{
temp = Q.peek();
Q.remove();
// Move to left child
if (temp.left != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.abs(temp.left.val - temp.val) == 1 )
Q.add(temp.left);
else
{
flag = 0 ;
break ;
}
}
// Move to right child
if (temp.right != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.abs(temp.right.val - temp.val) == 1 )
Q.add(temp.right);
else {
flag = 0 ;
break ;
}
}
}
if (flag != 0 )
return true ;
else
return false ;
} // Driver Code public static void main(String[] args)
{ // Constructing the Tree
node root = new node( 3 );
root.left = new node( 2 );
root.right = new node( 4 );
root.left.left = new node( 1 );
root.left.right = new node( 3 );
root.right.right = new node( 5 );
// Function Call
if (continuous(root))
System.out.print( "True\n" );
else
System.out.print( "False\n" );
} } // This code is contributed by Rajput-Ji |
# Python program for the above approach # Node structure class Node:
def __init__( self , x):
self .val = x
self .left = None
self .right = None
# Function to check if the tree is continuous or not def continuous(root):
# If root is None then tree isn't Continuous
if root is None :
return False
flag = 1
Q = []
Q.append(root)
temp = None
# BFS Traversal
while len (Q) ! = 0 :
temp = Q.pop( 0 )
# Move to left child
if temp.left is not None :
# if difference between parent and child is
# equal to 1 then do continue otherwise make
# flag = 0 and break
if abs (temp.left.val - temp.val) = = 1 :
Q.append(temp.left)
else :
flag = 0
break
# Move to right child
if temp.right is not None :
# if difference between parent and child is
# equal to 1 then do continue otherwise make
# flag = 0 and break
if abs (temp.right.val - temp.val) = = 1 :
Q.append(temp.right)
else :
flag = 0
break
if flag ! = 0 :
return True
else :
return False
# Driver Code # Constructing the Tree root = Node( 3 )
root.left = Node( 2 )
root.right = Node( 4 )
root.left.left = Node( 1 )
root.left.right = Node( 3 )
root.right.right = Node( 5 )
# Function Call if continuous(root):
print ( "True" )
else :
print ( "False" )
# This code is contributed by codebraxnzt |
// C# Code to check if the tree is continuous or not using System;
using System.Collections.Generic;
class GFG
{ // Node structure
public
class node
{
public
int val;
public
node left;
public
node right;
public node()
{
this .val = 0;
this .left = null ;
this .right = null ;
}
public node( int x)
{
this .val = x;
this .left = null ;
this .right = null ;
}
public node( int x, node left, node right)
{
this .val = x;
this .left = left;
this .right = right;
}
};
// Function to check if the tree is continuous or not
static bool continuous(node root)
{
// If root is Null then tree isn't Continuous
if (root == null )
return false ;
int flag = 1;
Queue<node> Q = new Queue<node>();
Q.Enqueue(root);
node temp;
// BFS Traversal
while (Q.Count != 0)
{
temp = Q.Peek();
Q.Dequeue();
// Move to left child
if (temp.left != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.Abs(temp.left.val - temp.val) == 1)
Q.Enqueue(temp.left);
else
{
flag = 0;
break ;
}
}
// Move to right child
if (temp.right != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.Abs(temp.right.val - temp.val) == 1)
Q.Enqueue(temp.right);
else {
flag = 0;
break ;
}
}
}
if (flag != 0)
return true ;
else
return false ;
}
// Driver Code
public static void Main(String[] args)
{
// Constructing the Tree
node root = new node(3);
root.left = new node(2);
root.right = new node(4);
root.left.left = new node(1);
root.left.right = new node(3);
root.right.right = new node(5);
// Function Call
if (continuous(root))
Console.Write( "True\n" );
else
Console.Write( "False\n" );
}
} // This code is contributed by Rajput-Ji |
<script> // Javascript Code to check if the tree is continuous or not // Node structure class Node { constructor(x)
{
this .val = x;
this .left = null ;
this .right= null ;
}
} // Function to check if the tree is continuous or not function continuous(root)
{ // If root is Null then tree isn't Continuous
if (root == null )
return false ;
let flag = 1;
let Q = [];
Q.push(root);
let temp;
// BFS Traversal
while (Q.length!=0)
{
temp = Q.shift();
// Move to left child
if (temp.left != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.abs(temp.left.val - temp.val) == 1)
Q.push(temp.left);
else
{
flag = 0;
break ;
}
}
// Move to right child
if (temp.right != null )
{
// if difference between parent and child is
// equal to 1 then do continue otherwise make
// flag = 0 and break
if (Math.abs(temp.right.val - temp.val) == 1)
Q.push(temp.right);
else {
flag = 0;
break ;
}
}
}
if (flag != 0)
return true ;
else
return false ;
} // Driver Code // Constructing the Tree let root = new Node(3);
root.left = new Node(2);
root.right = new Node(4);
root.left.left = new Node(1);
root.left.right = new Node(3);
root.right.right = new Node(5);
// Function Call if (continuous(root))
document.write( "True<br>" );
else document.write( "False<br>" );
// This code is contributed by avanitrachhadiya2155 </script> |
True
Time Complexity: O(n)
Auxiliary Space: O(N) ,here N is number of nodes in the tree.