Continuous Tree - GeeksforGeeks

06 Jul, 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++
Java
C#
Javascript
// 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 notbool 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 notimport java.util.*; class solution{ /* A binary tree node has data, pointer to left childand a pointer to right child */static class Node{    int data;    Node left, right;}; /* Helper function that allocates a new node with thegiven 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# program to check if a tree is continuous or notusing System; class solution{ /* A binary tree node has data, pointer to left childand a pointer to right child */class Node{    public int data;    public Node left, right;}; /* Helper function that allocates a new node with thegiven 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 childand 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 thegiven 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 notfunction 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>
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
Java
C#
Javascript
// CPP Code to check if the tree is continuous or not#include <bits/stdc++.h>using namespace std; // Node structurestruct 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 notbool 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 Codeint 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 notimport java.util.*;class GFG{ // Node structurestatic 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 notstatic 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 Codepublic 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# Code to check if the tree is continuous or notusing 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 structureclass Node{     constructor(x)    {        this.val = x;        this.left = null;        this.right= null;    }} // Function to check if the tree is continuous or notfunction 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 Treelet 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 Callif (continuous(root))    document.write("True<br>");else    document.write("False<br>"); // This code is contributed by avanitrachhadiya2155</script>
True
Time Complexity: O(n)
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@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. 
andrew1234
veejnas7
Rajput-Ji
clintra
itsok
surindertarika1234
avanitrachhadiya2155
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion
Write a Program to Find the Maximum Depth or Height of a Tree
Binary Tree | Set 3 (Types of Binary Tree)
Binary Tree | Set 2 (Properties)
A program to check if a binary tree is BST or not