python: recursion: find number of leaves of binary tree

def num_leaves(my_tree):
   count = 0
if my_tree.get_left() is None and my_tree.get_right() is None:
   count += 1
if my_tree.get_left():
   count += num_leaves(my_tree.get_left()) # added count +=
   if my_tree.get_right():
   count += num_leaves(my_tree.get_right()) # added count +=

   return count

a = BinaryTree(1)
a.insert_left(2)
a.insert_right(3)
a.insert_right(4)
a.get_right().insert_left(5)
print(num_leaves(a))

a = BinaryTree(1)
a.insert_left(2)
a.insert_right(3)
print(num_leaves(a))

class BinaryTree:
   ...your code...

   def is_leaf(self):
   return self.right is None and self.left is None

def count_leaves(self):
   if self.is_leaf():
   return 1
count = 0
if self.right is not None:
   count += self.right.count_leaves()
if self.left is not None:
   count += self.left.count_leaves()
return count

def num_leaves(my_tree):
   if my_tree is None:
   return 0
else:
   return num_leaves(my_tree.get_left()) +
      num_leaves(my_tree.get_right())

getLeafCount(node)
1) If node is NULL then
return 0.
2) Else If left and right child nodes are NULL
return 1.
3) Else recursively calculate leaf count of the tree using below formula.
Leaf count of a tree = Leaf count of left subtree +
   Leaf count of right subtree

The leaf count of binary tree is: 3

The leaf count of binary tree is: 3

  Input:
     1 /
     \
     2 3 /
     \/ \
  4 5 6 7

  Output: 4

1.
if root is null then
2.
return 0
3.
if root - > left is null and root - > right is null then
4.
return 1
5.
else
   6.
return Leaf_Count(root - > left) + Leaf_Count(root - > right)

class Node:
   def __init__(self, data):
   self.left = None
self.data = data
self.right = None

def leaf_count(root):
   if root is None:
   return 0
if root.left is None and root.right is None:
   return 1
else:
   return leaf_count(root.left) + leaf_count(root.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
root.right.right = Node(7)
print(leaf_count(root))

class Node {
   constructor(data) {
      this.left = null;
      this.data = data;
      this.right = null;
   }
}

function leafCount(root) {
   if (!root) return 0;
   if (!root.left && !root.right) return 1;
   else return leafCount(root.left) + leafCount(root.right);
}

const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
console.log(leafCount(root));

4

1.
if root is null then
return 0
2. queue.enqueue(root)
3. count = 0
4.
while queue is not empty
5. node = queue.dequeue()
6.
if node - > left is null and node - > right is null then
7. count = count + 1
8.
else
   9.
if node - > left is not null then
10. queue.enqueue(node - > left)
11.
if node.right is not null then
12. queue.enqueue(node - > right)
13.
return count

#Python program to count leaf nodes in a binary tree using recursion #class
for creating Nodes of the binary treeclass Node: def __init__(self, data): self.data = data self.left = None self.right = None #class to count leaf nodes in a binary tree using recursionclass CountLeafNodes: #function to count leaf nodes in a binary tree using recursion def count_leaf_nodes(self, root): if root is None: return 0 #if there is no left child and no right child then it is a leaf node
if root.left == None and root.right == None: return 1
return self.count_leaf_nodes(root.left) + self.count_leaf_nodes(root.right) #driver codedef main(): #creating binary tree root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) root.left.left.left = Node(6) #creating object o = CountLeafNodes() print('No of nodes in the binary tree:', o.count_leaf_nodes(root)) if __name__ == '__main__': main()

If the input tree is
25
   /
   \
   27 19 /
   \/ \
17 91 13 55
then number of leaf nodes in this tree will be 4

 If the input tree is
 1\
 2\
 3\
 4\
 5
 then number of leaf nodes in this tree will be 1

If the input tree is
15
then number of leaf nodes in this tree will be 1

/* C Program to find the number of leaf nodes in a Tree */

#include <stdio.h>

#include <stdlib.h>

  public static void printLeaves(TreeNode node) {
     // base case
     if (node == null) {
        return;
     }

     if (node.isLeaf()) {
        System.out.printf("%s ", node.value);
     }

     printLeaves(node.left);
     printLeaves(node.right);

  }

/*
 * Java Program to print all leaf nodes of binary tree 
 * using recursion
 * input :   a
 *          / \
 *         b   f
 *        / \  / \
 *       c   e g  h
 *      /          \ 
 *     d            k 
 * 
 * output: d e g k 
 */

public class Main {

   public static void main(String[] args) throws Exception {

      // let's create a binary tree
      TreeNode d = new TreeNode("d");
      TreeNode e = new TreeNode("e");
      TreeNode g = new TreeNode("g");
      TreeNode k = new TreeNode("k");

      TreeNode c = new TreeNode("c", d, null);
      TreeNode h = new TreeNode("h", k, null);

      TreeNode b = new TreeNode("b", c, e);
      TreeNode f = new TreeNode("f", g, h);

      TreeNode root = new TreeNode("a", b, f);

      // print all leaf nodes of binary tree using recursion
      System.out
         .println("Printing all leaf nodes of binary tree in Java (recursively)");
      printLeaves(root);

   }

   /**
    * A class to represent a node in binary tree
    */
   private static class TreeNode {
      String value;
      TreeNode left;
      TreeNode right;

      TreeNode(String value) {
         this.value = value;
      }

      TreeNode(String data, TreeNode left, TreeNode right) {
         this.value = data;
         this.left = left;
         this.right = right;
      }

      boolean isLeaf() {
         return left == null ? right == null : false;
      }
   }

   /**
    * Java method to print leaf nodes using recursion
    * 
    * @param root
    * 
    */
   public static void printLeaves(TreeNode node) {
      // base case
      if (node == null) {
         return;
      }

      if (node.isLeaf()) {
         System.out.printf("%s ", node.value);
      }

      printLeaves(node.left);
      printLeaves(node.right);

   }
}

Output
Printing all leaf nodes of binary tree in Java(recursively)
d e g k

private int countLeaves(TreeNode node) {
   if (node == null)
      return 0;

   if (node.isLeaf()) {
      return 1;
   } else {
      return countLeaves(node.left) + countLeaves(node.right);
   }
}