Print Left View of a Binary Tree

A binary hierarchy is an ordered data structure used in the fields of mathematics and computer science to organize data so that component addition, deletion, and searching can be done to their fullest potential. It is made up of nodes, each of which can contain up to two offspring, which are the left child and the right child.

The essential elements and ideas related to a binary tree are as follows:

Node: Every node in a binary structure contains a piece of information known to be the "value" or "key," and it can have an absolute maximum amount of two child nodes, which include a left child and a right child.
Root Node: The root of the node is the tree's highest node. All other nodes can be traced back to the parent node.
Child Node: Every node can contain no more than a pair of child nodes, one on each side, the left and right. These child nodes may be null if the node has no left or right children.
The parent node: is the node that is situated above each additional node (with the exception of the root).
Leaf Node: A "leaf node" is an empty node, which means that neither of the left and right nodes that surround it are empty.

Binary trees have several benefits.

Effective Searching: By comparing values and traversing the tree based on comparisons, binary trees, specifically binary search trees (BSTs), offer effective searching algorithms that make it simple to discover a particular element within the tree quickly.

Effective Insertion and Deletion: Operations such as insertion and deletion are made possible by binary trees. The tree's structure makes it possible to make changes reasonably quickly while still keeping the pieces' original arrangement.

Balanced Binary Trees: Balanced binary trees, like AVL trees and red-black trees, preserve balance during insertions and deletions to make sure the depth of the tree stays close to logarithmic. This equilibrium helps search, insertion, and delete operations go smoothly.

Binary trees have drawbacks.

i) Asymmetrical Trees: A skewed binary tree can degenerate into a linked list, which results in less effective operations like searching, insertion, and deletion with time complexity closer to O(n) than the required O(log n).

ii) Inefficient for Some Operations: Due to the need for additional data structures or adjustments to the normal binary tree structure, there are better options than binary trees for operations like range searching.

iii) Sensitive to Input Order: The binary tree's shape can be influenced by the input elements' placement during insertion. In the worst situation, this might result in an unbalanced tree, which would have a major negative effect on performance.

Application

i) Binary Search Trees (BSTs) are applications of binary trees. Database systems, compilers, symbol tables, and other applications that call for effective searching, insertion, and deletion of data frequently use BSTs.

ii) Expression Parsing: Expression parsing techniques represent and evaluate arithmetic or logical phrases using binary expression trees.

iii) File systems are organized using binary trees, which makes it easier to access and manage files and directories.

iv) Networking and Routing Algorithms: Binary trees are utilized in networking applications, particularly in routing tables used in routers, to optimize routing algorithms.

Code

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def print_left_view(root):
    if not root:
        return
    
    queue = [root]

    While queue:
        # Print the leftmost node at the current level
        print(queue[0].val)

        # Number of nodes at the current level
        level_size = len(queue)

        # Process all nodes at the current level
        for i in range(level_size):
            Node = queue.pop(0)

            # Enqueue left child
            if node. Left:
                queue.append(node.left)

            # Enqueue the right child
            if node. right:
                queue.append(node.right)

# Example usage
if __name__ == "__main__":
    # Example binary tree:
    #         1
    #        / \
    #       2   3
    #      / \   \
    #     4   5   6
    root = TreeNode(1)
    root.left = TreeNode(2)
    root.right = TreeNode(3)
    root. Left.left = TreeNode(4)
    root. Left.right = TreeNode(5)
    root. right.right = TreeNode(6)

    print("Left view of the binary tree:")
    print_left_view(root)

Output:

Conclusion

We traverse the tree in level order, starting at the root and progressing to the leftmost node at each level, in order to print the left view of a binary tree. The left view of the binary tree is displayed by printing the leftmost nodes at each level. This method guarantees that the leftmost node at each level is printed first, giving us a view of the tree from the left. The program prints the leftmost node discovered at each level as it traverses the level-order tree using a queue. The accompanying Python code demonstrates the implementation of this algorithm.

Next TopicRemove all leaf nodes from the binary search tree

← prev next →