Python Tutorial

A binary tree is a binary data structure containing different nodes in which each node has at most two child nodes. These nodes follow some properties, including:

The left nodes of the binary tree have a lesser value than the root node.
The right nodes of the binary tree have a larger value than the root node.
All the sub-nodes must follow the above properties.

There are different ways by which we can traverse the binary search trees:

Inorder
Preorder
Postorder

Inorder Algorithm:

Left Subtree
Root Node
Right Subtree

Preorder Algorithm:

Root Node
Left Subtree
Right Subtree

Postorder Algorithm:

Left Subtree
Right Subtree
Root Node

Problem Statement

We have a preorder of a binary search tree. We need to print the lead nodes from the given preorder of the binary search tree. There can be any number of leaf nodes in the binary search tree.

Consider that all the node values are positive and are already preordered. We have to print the leaf nodes from the tree.

Let's understand this problem with a few examples.

Example 1:

Input:

Output:

70 149 388

Explanation:

The given Binary Search tree is:

Leaf Nodes from Preorder of a Binary Search Tree Using Python

The first element will be the root, as in preorder traversal; we first traverse the root node, then the left subtree, and then the right subtree. The elements greater than the root nodes are the elements in the left subtree, and the rest are in the right subtree. After making the binary search tree using this input, we get the elements [70, 149, 388] as the leaf nodes.

Example 2:

Input:

{ 42, 30, 27, 23, 19, 22, 26, 29, 15, 32, 31, 35, 38 }

Output:

15 22 26 29 31 38

Explanation:

The first element will be the root, as in preorder traversal; we first traverse the root node, then the left subtree, and then the right subtree. After making the binary search tree using this input, we get the elements [15, 22, 26, 29, 31, 38] are the leaf nodes.

There are two ways to find the leaf nodes from the preorder of the binary search tree.

1. Simple Method

In this, we will first find the preorder of the binary search tree using both inorder and preorder arrays. We first iterate the preorder array and then find the element for the inorder array.

Code:

def Search(inorder, ln, rn, k):
    mid = (ln + rn) >> 1
    if (inorder[mid] == k):
        return mid
    elif (inorder[mid] > k):
        return binarySearch(inorder, ln, mid - 1, k)
    else:
        return binarySearch(inorder, mid + 1, rn, k)

# leaf nodes from preorder traversal
def leafNodes_Pre(preorder, inorder, ln, rn, index, n):

# If there are no left subtree or right subtree, then print the leaf node
    if(ln == rn):
        print(inorder[ln], end = " ")
        index[0] = index[0] + 1
        return

# checking if the array is out of bound
    if (ln < 0 or ln > rn or rn >= n):
        return
# Searching index of preorder in the inorder array
    loc = binarySearch(inorder, ln, rn, preorder[index[0]])

# Increasing the index
    index[0] = index[0] + 1

# searhing the leaf node on the left subtree
    leafNodes_Pre(preorder, inorder, ln, loc - 1, index, n)

# searhing the leaf node on the right subtree
    leafNodes_Pre(preorder, inorder, loc + 1, rn, index, n)

def leafNodes(preorder, n):

# storing inorder traversal
    inorder = [0] * n

    for i in range(n):
        inorder[i] = preorder[i]

# Sorting the array after searching the preorder
    inorder.sort()

    index = [0]
    
# Printing the Leaf Nodes.
    leafNodes_Pre(preorder, inorder, 0, n - 1, index, n)

preorder = [42, 30, 27, 23, 19, 22, 26, 29, 15, 32, 31, 35, 38]
num = len(preorder)
print("The Leaf Nodes present in the binary search tree is: ")
leafNodes(preorder, num)

Output:

The Leaf Nodes present in the binary search tree are: 
15 22 26 29 31 38

Explanation:

Firstly, we will iterate the array to find the element in the inorder array. We have used binary search as it gives traversal in ascending order. We have set the range to find the element as [L, R]. If the value of L is equal to R, we get the leaf nodes. Now, we will start with the values of L = 0 and R = node - 1 for the root node of the preorder array. To search the element of the left subtree, we set the value of L = 0 and R = root index. We set L = root index + 1 and R = node -1 for the right subtree.

2. Using Stack

We will use a stack and traverse the array using two pointers.

Code:

def leafNode(preorder, node):
    cn = [ ]
    i = 0
    for j in range(1, node):
        found = False
        if preorder[i] > preorder[j]:
            cn.append(preorder[i])
 
        else:
            while len(cn) != 0:
                if preorder[j] > cn[-1]:
                    cn.pop(-1)
                    found = True
                else:
                    break
 
        if found:
            print(preorder[i], end = " ")
        i += 1
        
    print(preorder[node - 1])
    
if __name__ == '__main__':
    preorder = [300, 214, 120, 66, 45, 54, 78, 142, 198, 37, 100, 44]
    node = len(preorder) 
    print("The Leaf Nodes present in the binary search tree is: ")
    leafNode(preorder, node)

Output:

The Leaf Nodes present in the binary search tree are: 
54 78 44

Explanation:

In this, we have used two pointers, i and j. At the start, the value of i = 0 and j = 1. On comparing array[i] and array[j], if array[i] > array[j], it means array[j] is on the left side of a[i]. Then, a[i] will be pushed into the stack. We will now pop the elements till array[i] > top element of the stack and then print the jth value. The jth value will be the leaf nodes of the binary search tree.

Next TopicMatplotlib - Axes Class

← prev next →