Skip to content
Related Articles

Related Articles

Continuous Tree
  • Difficulty Level : Easy
  • Last Updated : 25 Jan, 2021

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. 
 

C++




// 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




// 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


C#




// 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


Output: 
 

Yes

This article is contributed by Shashank Mishra ( Gullu )



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.
 

C++14




// CPP Code to check if the tree is continuos 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 continuos or not
bool continuous(struct node* root)
{
 
    // If root is Null then tree isn't Continuos
    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




// JAVA Code to check if the tree is continuos 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 continuos or not
static boolean continuous(node root)
{
 
    // If root is Null then tree isn't Continuos
    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


C#




// C# Code to check if the tree is continuos 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 continuos or not
  static bool continuous(node root)
  {
 
    // If root is Null then tree isn't Continuos
    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


Output

True

Time Complexity: O(n)

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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

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
Recommended Articles
Page :