Python Program to Count Number of Non Leaf Nodes of a given Tree

When it is required to find the count of the non-leaf nodes in a Tree, a Tree_structure class is created with methods to set a root value, add nodes, and count non-leaf nodes. A non-leaf node is any node that has at least one child.

Below is a demonstration of the same −

What are Non-Leaf Nodes?

In a tree data structure:

• Leaf nodes − nodes with no children

• Non-leaf nodes − nodes that have at least one child (also called internal nodes)

Tree Structure Implementation

class Tree_structure:
    def __init__(self, data=None):
        self.key = data
        self.children = []

    def set_root(self, data):
        self.key = data

    def add_vals(self, node):
        self.children.append(node)

    def search_val(self, key):
        if self.key == key:
            return self
        for child in self.children:
            temp = child.search_val(key)
            if temp is not None:
                return temp
        return None

    def count_non_leaf_node(self):
        nonleaf_count = 0
        # If current node has children, it's a non-leaf node
        if self.children != []:
            nonleaf_count = 1
        # Recursively count non-leaf nodes in all children
        for child in self.children:
            nonleaf_count = nonleaf_count + child.count_non_leaf_node()
        return nonleaf_count

# Create a tree and add nodes
tree = Tree_structure(34)
child1 = Tree_structure(78)
child2 = Tree_structure(56)
child3 = Tree_structure(90)

tree.add_vals(child1)
child1.add_vals(child2)
child2.add_vals(child3)

# Count non-leaf nodes
count = tree.count_non_leaf_node()
print(f"The number of non-leaf nodes are: {count}")

The number of non-leaf nodes are: 3

Interactive Menu System

Here's the complete interactive program that allows users to build a tree and count non-leaf nodes ?

class Tree_structure:
    def __init__(self, data=None):
        self.key = data
        self.children = []

    def set_root(self, data):
        self.key = data

    def add_vals(self, node):
        self.children.append(node)

    def search_val(self, key):
        if self.key == key:
            return self
        for child in self.children:
            temp = child.search_val(key)
            if temp is not None:
                return temp
        return None

    def count_non_leaf_node(self):
        nonleaf_count = 0
        if self.children != []:
            nonleaf_count = 1
        for child in self.children:
            nonleaf_count = nonleaf_count + child.count_non_leaf_node()
        return nonleaf_count

tree = None

print('Menu (this assumes no duplicate keys)')
print('add <data> at root')
print('add <data> below <data>')
print('count')
print('quit')

while True:
    my_input = input('What operation would you like to perform ? ').split()

    operation = my_input[0].strip().lower()
    if operation == 'add':
        data = int(my_input[1])
        newNode = Tree_structure(data)
        suboperation = my_input[2].strip().lower()
        if suboperation == 'at':
            tree = newNode
        elif suboperation == 'below':
            position = my_input[3].strip().lower()
            key = int(position)
            ref_node = None
            if tree is not None:
                ref_node = tree.search_val(key)
            if ref_node is None:
                print('No such key.')
                continue
            ref_node.add_vals(newNode)

    elif operation == 'count':
        if tree is None:
            print('The tree is empty')
        else:
            count = tree.count_non_leaf_node()
            print('The number of non-leaf nodes are : {}'.format(count))

    elif operation == 'quit':
        break

How the Algorithm Works

The count_non_leaf_node() method uses recursion:

1. Check if current node has children − if yes, increment counter by 1

2. Recursively call the method on all children

3. Return the total count

Sample Output

Menu (this assumes no duplicate keys)
add <data> at root
add <data> below <data>
count
quit
What operation would you like to perform ? add 34 at root
What operation would you like to perform ? add 78 below 34
What operation would you like to perform ? add 56 below 78
What operation would you like to perform ? add 90 below 56
What operation would you like to perform ? count
The number of non-leaf nodes are : 3
What operation would you like to perform ? quit

Conclusion

This program demonstrates counting non-leaf nodes in a tree using recursive traversal. Any node with at least one child is considered a non-leaf node, and the algorithm efficiently counts them using depth-first traversal.