Find Duplicate Subtrees 🎯

Welcome to this comprehensive guide on finding duplicate subtrees! This lesson is designed to help you understand and implement algorithms related to data structures, specifically focusing on finding duplicate subtrees in a given binary tree. Let's dive in!

Binary Trees 📝

Before we delve into finding duplicate subtrees, let's first familiarize ourselves with binary trees. A binary tree is a data structure composed of nodes where each node has at most two children, called the left child and the right child.

markdown

In the above example, 1 is the root node, 2 and 3 are the left and right children of the root, respectively. 4 is a leaf node, meaning it has no children.

Duplicate Subtrees 💡

Now that we have a basic understanding of binary trees, let's focus on the main topic: duplicate subtrees. In a binary tree, a subtree is a tree rooted at a node in the original tree. Two subtrees are considered duplicate if they have the same structure, i.e., the same nodes with the same relative positions.

Here's a simple example:

markdown

In the above example, the subtrees rooted at nodes 1 in both trees are identical, so they are considered duplicate subtrees.

Finding Duplicate Subtrees 💡

To find duplicate subtrees, we can implement a recursive algorithm that compares the structure of a subtree with the rest of the tree, starting from the root.

Here's a step-by-step breakdown of the algorithm:

Initialize a map to store subtrees we've encountered.
Traverse the binary tree recursively.
For each node, create a subtree by including the node and all its descendants.
If the subtree is not in the map, add it and continue with the next subtree.
If the subtree is already in the map, we've found a duplicate subtree.

Let's see how the algorithm works with our example:

markdown

Initialize an empty map.
Traverse the left subtree of the first tree (rooted at 2).
Add the subtree rooted at 2 to the map.
Traverse the right subtree of the first tree (rooted at 3).
Add the subtree rooted at 3 to the map.
Traverse the left subtree of the second tree (rooted at 2).
Since we've already added this subtree to the map, we've found a duplicate subtree.

Code Example ✅

Here's a Python implementation of the algorithm:

python

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

def find_duplicates(root):
    subtrees = {}

    def find_duplicate_subtree(node, key):
        if not node:
            return

        key_str = str(node.val)
        if key_str in subtrees:
            print("Duplicate subtree found: ", subtrees[key_str])
            print("Found at: ", key_str)

        subtree_key = str((node.val, node.left, node.right))
        subtrees[subtree_key] = subtree_key
        find_duplicate_subtree(node.left, subtree_key)
        find_duplicate_subtree(node.right, subtree_key)

    find_duplicate_subtree(root, None)

# Example binary tree
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)

# Another example binary tree with a duplicate subtree
another_root = Node(1)
another_root.left = Node(2)
another_root.right = Node(3)
another_root.left.left = Node(4)

# Find duplicate subtrees
find_duplicates(root)
find_duplicates(another_root)

Quiz 💡

By the end of this lesson, you should have a solid understanding of finding duplicate subtrees in a binary tree. Happy coding! 🎉