# Find Count of Single Valued Subtrees

Given a binary tree, write a program to count the number of Single Valued Subtrees. A Single Valued Subtree is one in which all the nodes have same value. Expected time complexity is O(n).

Example:

`Input: root of below tree              5             / \            1   5           / \   \          5   5   5Output: 4There are 4 subtrees with single values.Input: root of below tree              5             / \            4   5           / \   \          4   4   5                Output: 5There are five subtrees with single values.`

We strongly recommend you to minimize your browser and try this yourself first.

A Simple Solution is to traverse the tree. For every traversed node, check if all values under this node are same or not. If same, then increment count. Time complexity of this solution is O(n2).
An Efficient Solution is to traverse the tree in bottom up manner. For every subtree visited, return true if subtree rooted under it is single valued and increment count. So the idea is to use count as a reference parameter in recursive calls and use returned values to find out if left and right subtrees are single valued or not.

Below is the implementation of above idea.

## C++

 `// C++ program to find count of single valued subtrees` `#include` `using` `namespace` `std;`   `// A Tree node` `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* left, *right;` `};`   `// Utility function to create a new node` `Node* newNode(``int` `data)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->data = data;` `    ``temp->left = temp->right = NULL;` `    ``return` `(temp);` `}`   `// This function increments count by number of single ` `// valued subtrees under root. It returns true if subtree ` `// under root is Singly, else false.` `bool` `countSingleRec(Node* root, ``int` `&count)` `{` `    ``// Return true to indicate NULL` `    ``if` `(root == NULL)` `       ``return` `true``;`   `    ``// Recursively count in left and right subtrees also` `    ``bool` `left = countSingleRec(root->left, count);` `    ``bool` `right = countSingleRec(root->right, count);`   `    ``// If any of the subtrees is not singly, then this` `    ``// cannot be singly.` `    ``if` `(left == ``false` `|| right == ``false``)` `       ``return` `false``;`   `    ``// If left subtree is singly and non-empty, but data` `    ``// doesn't match` `    ``if` `(root->left && root->data != root->left->data)` `        ``return` `false``;`   `    ``// Same for right subtree` `    ``if` `(root->right && root->data != root->right->data)` `        ``return` `false``;`   `    ``// If none of the above conditions is true, then` `    ``// tree rooted under root is single valued, increment` `    ``// count and return true.` `    ``count++;` `    ``return` `true``;` `}`   `// This function mainly calls countSingleRec()` `// after initializing count as 0` `int` `countSingle(Node* root)` `{` `    ``// Initialize result` `    ``int` `count = 0;`   `    ``// Recursive function to count` `    ``countSingleRec(root, count);`   `    ``return` `count;` `}`   `// Driver program to test` `int` `main()` `{` `    ``/* Let us construct the below tree` `            ``5` `          ``/   \` `        ``4      5` `      ``/  \      \` `     ``4    4      5 */` `    ``Node* root        = newNode(5);` `    ``root->left        = newNode(4);` `    ``root->right       = newNode(5);` `    ``root->left->left  = newNode(4);` `    ``root->left->right = newNode(4);` `    ``root->right->right = newNode(5);`   `    ``cout << ``"Count of Single Valued Subtrees is "` `         ``<< countSingle(root);` `    ``return` `0;` `}`

## Java

 `// Java program to find count of single valued subtrees` ` `  `/* Class containing left and right child of current ` ` ``node and key value*/` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right;` ` `  `    ``public` `Node(``int` `item) ` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}` ` `  `class` `Count ` `{` `    ``int` `count = ``0``;` `}` ` `  `class` `BinaryTree ` `{` `    ``Node root;  ` `    ``Count ct = ``new` `Count();` `     `  `    ``// This function increments count by number of single ` `    ``// valued subtrees under root. It returns true if subtree ` `    ``// under root is Singly, else false.` `    ``boolean` `countSingleRec(Node node, Count c) ` `    ``{` `        ``// Return false to indicate NULL` `        ``if` `(node == ``null``)` `            ``return` `true``;` `         `  `        ``// Recursively count in left and right subtrees also` `        ``boolean` `left = countSingleRec(node.left, c);` `        ``boolean` `right = countSingleRec(node.right, c);` ` `  `        ``// If any of the subtrees is not singly, then this` `        ``// cannot be singly.` `        ``if` `(left == ``false` `|| right == ``false``)` `            ``return` `false``;` ` `  `        ``// If left subtree is singly and non-empty, but data` `        ``// doesn't match` `        ``if` `(node.left != ``null` `&& node.data != node.left.data)` `            ``return` `false``;` ` `  `        ``// Same for right subtree` `        ``if` `(node.right != ``null` `&& node.data != node.right.data)` `            ``return` `false``;` ` `  `        ``// If none of the above conditions is true, then` `        ``// tree rooted under root is single valued, increment` `        ``// count and return true.` `        ``c.count++;` `        ``return` `true``;` `    ``}` ` `  `    ``// This function mainly calls countSingleRec()` `    ``// after initializing count as 0` `    ``int` `countSingle() ` `    ``{` `        ``return` `countSingle(root);` `    ``}` ` `  `    ``int` `countSingle(Node node) ` `    ``{` `        ``// Recursive function to count` `        ``countSingleRec(node, ct);` `        ``return` `ct.count;` `    ``}` ` `  `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String args[]) ` `    ``{` `           ``/* Let us construct the below tree` `                ``5` `              ``/   \` `            ``4      5` `          ``/  \      \` `         ``4    4      5 */` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(``5``);` `        ``tree.root.left = ``new` `Node(``4``);` `        ``tree.root.right = ``new` `Node(``5``);` `        ``tree.root.left.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``4``);` `        ``tree.root.right.right = ``new` `Node(``5``);` ` `  `        ``System.out.println(``"The count of single valued sub trees is : "` `                                            ``+ tree.countSingle());` `    ``}` `}` ` `  `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python program to find the count of single valued subtrees`   `# Node Structure ` `class` `Node:` `    ``# Utility function to create a new node` `    ``def` `__init__(``self` `,data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `# This function increments count by number of single ` `# valued subtrees under root. It returns true if subtree ` `# under root is Singly, else false.` `def` `countSingleRec(root , count):` `    ``# Return False to indicate None` `    ``if` `root ``is` `None` `:` `        ``return` `True`   `    ``# Recursively count in left and right subtrees also` `    ``left ``=` `countSingleRec(root.left , count)` `    ``right ``=` `countSingleRec(root.right , count)` `    `  `    ``# If any of the subtrees is not singly, then this` `    ``# cannot be singly` `    ``if` `left ``=``=` `False` `or` `right  ``=``=` `False` `:` `        ``return` `False` `    `  `    ``# If left subtree is singly and non-empty , but data` `    ``# doesn't match` `    ``if` `root.left ``and` `root.data !``=` `root.left.data:` `        ``return` `False`   `    ``# same for right subtree` `    ``if` `root.right ``and` `root.data !``=` `root.right.data:` `        ``return` `False`   `    ``# If none of the above conditions is True, then ` `    ``# tree rooted under root is single valued,increment` `    ``# count and return true` `    ``count[``0``] ``+``=` `1` `    ``return` `True`     `# This function mainly class countSingleRec()` `# after initializing count as 0` `def` `countSingle(root):` `    ``# initialize result` `    ``count ``=` `[``0``]`   `    ``# Recursive function to count` `    ``countSingleRec(root , count)`   `    ``return` `count[``0``]`     `# Driver program to test `   `"""Let us construct the below tree ` `            ``5` `          ``/   \` `        ``4       5` `       ``/  \      \` `      ``4    4      5` `"""` `root ``=` `Node(``5``)` `root.left ``=` `Node(``4``)` `root.right ``=` `Node(``5``)` `root.left.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``4``)` `root.right.right ``=` `Node(``5``)` `countSingle(root)` `print` `(``"Count of Single Valued Subtrees is"` `, countSingle(root))`   `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `using` `System;`   `// C# program to find count of single valued subtrees `   `/* Class containing left and right child of current  ` ` ``node and key value*/` `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `Count` `{` `    ``public` `int` `count = 0;` `}`   `public` `class` `BinaryTree` `{` `    ``public` `Node root;` `    ``public` `Count ct = ``new` `Count();`   `    ``// This function increments count by number of single  ` `    ``// valued subtrees under root. It returns true if subtree  ` `    ``// under root is Singly, else false. ` `    ``public` `virtual` `bool` `countSingleRec(Node node, Count c)` `    ``{` `        ``// Return false to indicate NULL ` `        ``if` `(node == ``null``)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``// Recursively count in left and right subtrees also ` `        ``bool` `left = countSingleRec(node.left, c);` `        ``bool` `right = countSingleRec(node.right, c);`   `        ``// If any of the subtrees is not singly, then this ` `        ``// cannot be singly. ` `        ``if` `(left == ``false` `|| right == ``false``)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// If left subtree is singly and non-empty, but data ` `        ``// doesn't match ` `        ``if` `(node.left != ``null` `&& node.data != node.left.data)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// Same for right subtree ` `        ``if` `(node.right != ``null` `&& node.data != node.right.data)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// If none of the above conditions is true, then ` `        ``// tree rooted under root is single valued, increment ` `        ``// count and return true. ` `        ``c.count++;` `        ``return` `true``;` `    ``}`   `    ``// This function mainly calls countSingleRec() ` `    ``// after initializing count as 0 ` `    ``public` `virtual` `int` `countSingle()` `    ``{` `        ``return` `countSingle(root);` `    ``}`   `    ``public` `virtual` `int` `countSingle(Node node)` `    ``{` `        ``// Recursive function to count ` `        ``countSingleRec(node, ct);` `        ``return` `ct.count;` `    ``}`   `    ``// Driver program to test above functions ` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `           ``/* Let us construct the below tree ` `                ``5 ` `              ``/   \ ` `            ``4      5 ` `          ``/  \      \ ` `         ``4    4      5 */` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(5);` `        ``tree.root.left = ``new` `Node(4);` `        ``tree.root.right = ``new` `Node(5);` `        ``tree.root.left.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(4);` `        ``tree.root.right.right = ``new` `Node(5);`   `        ``Console.WriteLine(``"The count of single valued sub trees is : "` `+ tree.countSingle());` `    ``}` `}`   `  ``// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```Count of Single Valued Subtrees is 5

```

Time complexity of this solution is O(n) where n is number of nodes in given binary tree.
Auxiliary Space: O(h) where h is the height of the tree due to recursion call.

Here’s the overall approach of the algorithm using BFS:

• The algorithm includes a helper method to check if a given node is part of a singly valued subtree. It compares the node’s value with its left and right child nodes’ values.
• The algorithm initializes the count variable to 0.
• It performs a BFS traversal using a queue. It starts by enqueuing the root node.
• Inside the BFS loop, it dequeues a node and checks if it is singly valued.
• If the current node is singly valued, it increments the count variable.
• The algorithm enqueues the left and right child nodes of the current node, if they exist.
• Once the BFS traversal is complete, the count variable contains the total count of single-valued subtrees.
• The algorithm returns the count of single-valued subtrees.

Here is the code of above approach:

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `// Class containing left and right child of current` `// node and key value` `class` `Node` `{` `public``:` `    ``int` `data;` `    ``Node *left, *right;`   `    ``Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = NULL;` `    ``}` `};`   `class` `Count` `{` `public``:` `    ``int` `count = 0;` `};`   `class` `BinaryTree` `{` `public``:` `    ``Node *root;` `    ``Count ct;`   `    ``// This function increments count by number of single` `    ``// valued subtrees under root. It returns true if subtree` `    ``// under root is Singly, else false.` `    ``bool` `countSingleRec(Node *node, Count &c)` `    ``{` `        ``// Return false to indicate NULL` `        ``if` `(node == NULL)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``// Perform BFS` `        ``queue q;` `        ``q.push(node);`   `        ``while` `(!q.empty())` `        ``{` `            ``Node *curr = q.front();` `            ``q.pop();`   `            ``// Check if the current node is singly valued` `            ``if` `(isSingleValued(curr))` `            ``{` `                ``c.count++;` `            ``}`   `            ``// Enqueue the left and right child nodes` `            ``if` `(curr->left != NULL)` `            ``{` `                ``q.push(curr->left);` `            ``}` `            ``if` `(curr->right != NULL)` `            ``{` `                ``q.push(curr->right);` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Helper function to check if a node is singly valued` `    ``bool` `isSingleValued(Node *node)` `    ``{` `        ``if` `(node->left != NULL && node->data != node->left->data)` `        ``{` `            ``return` `false``;` `        ``}` `        ``if` `(node->right != NULL && node->data != node->right->data)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// This function mainly calls countSingleRec()` `    ``// after initializing count as 0` `    ``int` `countSingle()` `    ``{` `        ``return` `countSingle(root);` `    ``}`   `    ``int` `countSingle(Node *node)` `    ``{` `        ``// Recursive function to count` `        ``countSingleRec(node, ct);` `        ``return` `ct.count;` `    ``}` `};`   `// Driver program to test above functions` `int` `main()` `{` `    ``/* Let us construct the below tree` `            ``5` `           ``/ \` `          ``4   5` `         ``/ \   \` `        ``4   4   5 */` `    ``BinaryTree tree;` `    ``tree.root = ``new` `Node(5);` `    ``tree.root->left = ``new` `Node(4);` `    ``tree.root->right = ``new` `Node(5);` `    ``tree.root->left->left = ``new` `Node(4);` `    ``tree.root->left->right = ``new` `Node(4);` `    ``tree.root->right->right = ``new` `Node(5);`   `    ``cout << ``"The count of single valued subtrees is: "` `<< tree.countSingle() << endl;`   `    ``return` `0;` `}`

## Java

 `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``Node(``int` `item) {` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `Count {` `    ``int` `count = ``0``;` `}`   `class` `BinaryTree {` `    ``Node root;` `    ``Count ct = ``new` `Count();`   `    ``// This function increments count by number of single valued subtrees under root.` `    ``// It returns true if subtree under root is singly valued, else false.` `    ``boolean` `countSingleRec(Node node, Count c) {` `        ``if` `(node == ``null``) {` `            ``return` `true``;` `        ``}`   `        ``Queue queue = ``new` `LinkedList<>();` `        ``queue.add(node);`   `        ``while` `(!queue.isEmpty()) {` `            ``Node curr = queue.poll();`   `            ``if` `(isSingleValued(curr)) {` `                ``c.count++;` `            ``}`   `            ``if` `(curr.left != ``null``) {` `                ``queue.add(curr.left);` `            ``}` `            ``if` `(curr.right != ``null``) {` `                ``queue.add(curr.right);` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Helper function to check if a node is singly valued` `    ``boolean` `isSingleValued(Node node) {` `        ``if` `(node.left != ``null` `&& node.data != node.left.data) {` `            ``return` `false``;` `        ``}` `        ``if` `(node.right != ``null` `&& node.data != node.right.data) {` `            ``return` `false``;` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// This function mainly calls countSingleRec() after initializing count as 0` `    ``int` `countSingle() {` `        ``return` `countSingleRec(root, ct) ? ct.count : ``0``;` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String[] args) {` `        ``// Let us construct the below tree` `        ``//        5` `        ``//       / \` `        ``//      4   5` `        ``//     / \   \` `        ``//    4   4   5` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(``5``);` `        ``tree.root.left = ``new` `Node(``4``);` `        ``tree.root.right = ``new` `Node(``5``);` `        ``tree.root.left.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``4``);` `        ``tree.root.right.right = ``new` `Node(``5``);`   `        ``System.out.println(``"The count of single valued subtrees is: "` `+ tree.countSingle());` `    ``}` `}`

## Python

 `from` `collections ``import` `deque`   `class` `Node:` `    ``def` `__init__(``self``, item):` `        ``self``.data ``=` `item` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `class` `Count:` `    ``def` `__init__(``self``):` `        ``self``.count ``=` `0`   `class` `BinaryTree:` `    ``def` `__init__(``self``):` `        ``self``.root ``=` `None` `        ``self``.ct ``=` `Count()`   `    ``def` `countSingleRec(``self``, node, c):` `        ``if` `node ``is` `None``:` `            ``return` `True`   `        ``q ``=` `deque()` `        ``q.append(node)`   `        ``while` `q:` `            ``curr ``=` `q.popleft()`   `            ``if` `self``.isSingleValued(curr):` `                ``c.count ``+``=` `1`   `            ``if` `curr.left:` `                ``q.append(curr.left)` `            ``if` `curr.right:` `                ``q.append(curr.right)`   `        ``return` `True`   `    ``def` `isSingleValued(``self``, node):` `        ``if` `node.left ``and` `node.data !``=` `node.left.data:` `            ``return` `False` `        ``if` `node.right ``and` `node.data !``=` `node.right.data:` `            ``return` `False`   `        ``return` `True`   `    ``def` `countSingle(``self``):` `        ``self``.countSingleRec(``self``.root, ``self``.ct)` `        ``return` `self``.ct.count`   `if` `__name__ ``=``=` `"__main__"``:` `    ``# Construct the tree` `    ``tree ``=` `BinaryTree()` `    ``tree.root ``=` `Node(``5``)` `    ``tree.root.left ``=` `Node(``4``)` `    ``tree.root.right ``=` `Node(``5``)` `    ``tree.root.left.left ``=` `Node(``4``)` `    ``tree.root.left.right ``=` `Node(``4``)` `    ``tree.root.right.right ``=` `Node(``5``)`   `    ``print``(``"The count of single valued subtrees is:"``, tree.countSingle())`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `/* Class containing left and right child of current` `node and key value*/` `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `Count` `{` `    ``public` `int` `count = 0;` `}`   `public` `class` `BinaryTree` `{` `    ``public` `Node root;` `    ``public` `Count ct = ``new` `Count();`   `    ``// This function increments count by number of single` `    ``// valued subtrees under root. It returns true if subtree` `    ``// under root is Singly, else false.` `    ``public` `virtual` `bool` `countSingleRec(Node node, Count c)` `    ``{` `        ``// Return false to indicate NULL` `        ``if` `(node == ``null``)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``// Perform BFS` `        ``Queue queue = ``new` `Queue();` `        ``queue.Enqueue(node);`   `        ``while` `(queue.Count > 0)` `        ``{` `            ``Node curr = queue.Dequeue();`   `            ``// Check if the current node is singly valued` `            ``if` `(isSingleValued(curr))` `            ``{` `                ``c.count++;` `            ``}`   `            ``// Enqueue the left and right child nodes` `            ``if` `(curr.left != ``null``)` `            ``{` `                ``queue.Enqueue(curr.left);` `            ``}` `            ``if` `(curr.right != ``null``)` `            ``{` `                ``queue.Enqueue(curr.right);` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Helper function to check if a node is singly valued` `    ``private` `bool` `isSingleValued(Node node)` `    ``{` `        ``if` `(node.left != ``null` `&& node.data != node.left.data)` `        ``{` `            ``return` `false``;` `        ``}` `        ``if` `(node.right != ``null` `&& node.data != node.right.data)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// This function mainly calls countSingleRec()` `    ``// after initializing count as 0` `    ``public` `virtual` `int` `countSingle()` `    ``{` `        ``return` `countSingle(root);` `    ``}`   `    ``public` `virtual` `int` `countSingle(Node node)` `    ``{` `        ``// Recursive function to count` `        ``countSingleRec(node, ct);` `        ``return` `ct.count;` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``/* Let us construct the below tree` `                ``5` `               ``/ \` `              ``4   5` `             ``/ \   \` `            ``4   4   5 */` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(5);` `        ``tree.root.left = ``new` `Node(4);` `        ``tree.root.right = ``new` `Node(5);` `        ``tree.root.left.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(4);` `        ``tree.root.right.right = ``new` `Node(5);`   `        ``Console.WriteLine(``"The count of single valued subtrees is: "` `+ tree.countSingle());` `    ``}` `}`

## Javascript

 `class Node {` `    ``constructor(item) {` `        ``this``.data = item;` `        ``this``.left = ``this``.right = ``null``;` `    ``}` `}`   `class Count {` `    ``constructor() {` `        ``this``.count = 0;` `    ``}` `}`   `class BinaryTree {` `    ``constructor() {` `        ``this``.root = ``null``;` `        ``this``.ct = ``new` `Count();` `    ``}`   `    ``// This function increments count by the number of single` `    ``// valued subtrees under root. It returns true if the subtree` `    ``// under root is singly, else false.` `    ``countSingleRec(node, c) {` `        ``// Return true to indicate null node` `        ``if` `(node === ``null``) {` `            ``return` `true``;` `        ``}`   `        ``// Perform BFS` `        ``const queue = [];` `        ``queue.push(node);`   `        ``while` `(queue.length !== 0) {` `            ``const curr = queue.shift();`   `            ``// Check if the current node is singly valued` `            ``if` `(``this``.isSingleValued(curr)) {` `                ``c.count++;` `            ``}`   `            ``// Enqueue the left and right child nodes` `            ``if` `(curr.left !== ``null``) {` `                ``queue.push(curr.left);` `            ``}` `            ``if` `(curr.right !== ``null``) {` `                ``queue.push(curr.right);` `            ``}` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// Helper function to check if a node is singly valued` `    ``isSingleValued(node) {` `        ``if` `(node.left !== ``null` `&& node.data !== node.left.data) {` `            ``return` `false``;` `        ``}` `        ``if` `(node.right !== ``null` `&& node.data !== node.right.data) {` `            ``return` `false``;` `        ``}`   `        ``return` `true``;` `    ``}`   `    ``// This function mainly calls countSingleRec()` `    ``// after initializing count as 0` `    ``countSingle() {` `        ``return` `this``.countSingle(``this``.root);` `    ``}`   `    ``countSingle(node) {` `        ``// Recursive function to count` `        ``this``.countSingleRec(node, ``this``.ct);` `        ``return` `this``.ct.count;` `    ``}` `}`   `// Driver program to test above functions` `function` `main() {` `    ``/* Let us construct the below tree` `                ``5` `               ``/ \` `              ``4   5` `             ``/ \   \` `            ``4   4   5 */`   `    ``const tree = ``new` `BinaryTree();` `    ``tree.root = ``new` `Node(5);` `    ``tree.root.left = ``new` `Node(4);` `    ``tree.root.right = ``new` `Node(5);` `    ``tree.root.left.left = ``new` `Node(4);` `    ``tree.root.left.right = ``new` `Node(4);` `    ``tree.root.right.right = ``new` `Node(5);`   `    ``console.log(``"The count of single valued subtrees is:"``, tree.countSingle());` `}`   `main();`

Output

`The count of single valued sub trees is : 5`

Time complexity: O(n),  where n is the number of nodes in given binary tree.
Auxiliary Space: O(h), where h is the height of the tree due to recursion call.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!