Recursion on Trees in Python
Last Updated :
16 Apr, 2024
In Python, recursion is implemented by defining a function that makes a call to itself within its definition. This process continues until a base case is reached, which is a condition where the function returns a value without making any further recursive calls. Without a base case, the recursion would continue indefinitely, leading to what's known as "infinite recursion," which can cause the program to crash.
- Depth-First Search (DFS) is a traversal algorithm that explores as far as possible along each branch before backtracking.
- In a recursive implementation, we typically perform a depth-first traversal by recursively visiting the child nodes of each node.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def dfs_recursive(node):
if node is None:
return
# Visit the current node
print(node.value)
# Traverse left subtree
dfs_recursive(node.left)
# Traverse right subtree
dfs_recursive(node.right)
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
# Perform DFS recursively
print("Depth-First Search (DFS) Recursive:")
dfs_recursive(root)
OutputDepth-First Search (DFS) Recursive:
1
2
4
5
3
6
7
Auxiliary Space: O(n)
Time Complexity: O(n)
- The height of a tree is the length of the longest path from the root node to a leaf node.
- The depth of a node is the length of the path from the root to that node.
- These can be calculated recursively by traversing the tree and keeping track of the depth or height as we go.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def tree_height(node):
if node is None:
return 0
else:
left_height = tree_height(node.left)
right_height = tree_height(node.right)
return max(left_height, right_height) + 1
def tree_depth(node):
if node is None:
return 0
else:
left_depth = tree_depth(node.left)
right_depth = tree_depth(node.right)
return max(left_depth, right_depth) + 1
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
# Calculate height and depth
print("Height of the tree:", tree_height(root))
print("Depth of the tree:", tree_depth(root))
OutputHeight of the tree: 3
Depth of the tree: 3
Auxiliary Space: O(n)
Time Complexity: O(n)
Tree Size using Recursion in Python:
- The size of a tree is the total number of nodes in the tree, including the root node and all its descendants.
- This can be calculated recursively by summing up the sizes of the left and right subtrees and adding 1 for the root node.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def tree_size(node):
if node is None:
return 0
else:
left_size = tree_size(node.left)
right_size = tree_size(node.right)
return left_size + right_size + 1
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
# Calculate the size of the tree
print("Size of the tree:", tree_size(root))
OutputSize of the tree: 7
Auxiliary Space: O(n)
Time Complexity: O(n)
- To find the maximum or minimum element in a tree, we can recursively traverse the tree and compare values at each node.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def find_max(node):
if node is None:
return float('-inf')
else:
max_left = find_max(node.left)
max_right = find_max(node.right)
return max(node.value, max_left, max_right)
def find_min(node):
if node is None:
return float('inf')
else:
min_left = find_min(node.left)
min_right = find_min(node.right)
return min(node.value, min_left, min_right)
# Example usage:
# Create a binary tree
root = TreeNode(5)
root.left = TreeNode(3)
root.right = TreeNode(7)
root.left.left = TreeNode(2)
root.left.right = TreeNode(4)
root.right.left = TreeNode(6)
root.right.right = TreeNode(8)
# Find maximum and minimum elements
print("Maximum element in the tree:", find_max(root))
print("Minimum element in the tree:", find_min(root))
OutputMaximum element in the tree: 8
Minimum element in the tree: 2
Auxiliary Space: O(n)
Time Complexity: O(n)
- Checking for symmetry in a tree involves comparing the left and right subtrees of the root recursively.
- At each step, we compare corresponding nodes in the left and right subtrees.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def is_symmetric(left, right):
# Base case: If both nodes are None, they are symmetric
if left is None and right is None:
return True
# If only one node is None or their values are different, they are not symmetric
if left is None or right is None or left.value != right.value:
return False
# Recursively check the symmetry of corresponding nodes in the left and right subtrees
return is_symmetric(left.left, right.right) and is_symmetric(left.right, right.left)
def check_symmetry(root):
# Empty tree is symmetric
if root is None:
return True
# Check the symmetry of the left and right subtrees
return is_symmetric(root.left, root.right)
# Example usage:
# Create a symmetric binary tree
symmetric_root = TreeNode(1)
symmetric_root.left = TreeNode(2)
symmetric_root.right = TreeNode(2)
symmetric_root.left.left = TreeNode(3)
symmetric_root.left.right = TreeNode(4)
symmetric_root.right.left = TreeNode(4)
symmetric_root.right.right = TreeNode(3)
# Create a non-symmetric binary tree
non_symmetric_root = TreeNode(1)
non_symmetric_root.left = TreeNode(2)
non_symmetric_root.right = TreeNode(2)
non_symmetric_root.left.right = TreeNode(3)
non_symmetric_root.right.right = TreeNode(3)
# Check symmetry
print("Is the symmetric tree symmetric?", check_symmetry(symmetric_root))
print("Is the non-symmetric tree symmetric?", check_symmetry(non_symmetric_root))
OutputIs the symmetric tree symmetric? True
Is the non-symmetric tree symmetric? False
Auxiliary Space: O(n)
Time Complexity: O(n)
- Path finding involves finding a path from the root of the tree to a given node.
- We can use recursion to traverse the tree and keep track of the path.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def find_path(root, target, path=None):
if path is None:
path = []
if root is None:
return []
path.append(root.value)
if root.value == target:
return path
left_path = find_path(root.left, target, path.copy())
right_path = find_path(root.right, target, path.copy())
if left_path:
return left_path
elif right_path:
return right_path
else:
return []
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
# Find path to node 5
target_node = 5
path_to_node = find_path(root, target_node)
if path_to_node:
print(f"Path to node {target_node}: {path_to_node}")
else:
print(f"Node {target_node} not found in the tree.")
OutputPath to node 5: [1, 2, 5]
Auxiliary Space : O(n * h)
Time Complexity: O(n)
- The Lowest Common Ancestor (LCA) of two nodes in a binary tree is the lowest node in the tree that has both nodes as descendants.
- We can use recursion to find the LCA of two given nodes.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def find_lca(root, node1, node2):
if root is None:
return None
# If the root is one of the nodes, it is the LCA
if root.value == node1 or root.value == node2:
return root
# Recursively find LCA in left and right subtrees
left_lca = find_lca(root.left, node1, node2)
right_lca = find_lca(root.right, node1, node2)
# If both nodes are found in different subtrees, root is the LCA
if left_lca and right_lca:
return root
# Otherwise, return the non-empty subtree
return left_lca if left_lca else right_lca
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
# Find LCA of nodes 4 and 5
node1_value = 4
node2_value = 5
lca_node = find_lca(root, node1_value, node2_value)
if lca_node:
print(f"LCA of nodes {node1_value} and {node2_value} is: {lca_node.value}")
else:
print(f"Nodes {node1_value} and {node2_value} are not found in the tree or they don't have a common ancestor.")
OutputLCA of nodes 4 and 5 is: 2
Auxiliary Space: O(n)
Time Complexity: O(n)
Morris Traversal using Recursion in Python:
Morris Traversal is an in-order tree traversal algorithm that does not use recursion or a stack. Instead, it modifies the tree structure by linking the rightmost node of the left subtree to the current node, allowing traversal without additional space.
Below is the implementation of the above code:
Python3
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def morris_inorder_traversal(root):
current = root
while current:
if current.left is None:
print(current.value, end=" ")
current = current.right
else:
# Find the rightmost node in the left subtree
predecessor = current.left
while predecessor.right and predecessor.right != current:
predecessor = predecessor.right
if predecessor.right is None:
predecessor.right = current
current = current.left
else:
predecessor.right = None
print(current.value, end=" ")
current = current.right
# Example usage:
# Create a binary tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
# Perform Morris in-order traversal
print("Morris In-order Traversal:")
morris_inorder_traversal(root)
OutputMorris In-order Traversal:
4 2 5 1 3
Auxiliary Space: O(1)
Time Complexity: O(n)
Similar Reads
Tree Sort in Python
Tree sort is a sorting algorithm that builds a Binary Search Tree (BST) from the elements of the array to be sorted and then performs an in-order traversal of the BST to get the elements in sorted order. In this article, we will learn about the basics of Tree Sort along with its implementation in Py
3 min read
Rerooting Techniques in Python
Rerooting techniques are typically used in the context of rooted trees in computational problems, such as dynamic programming on trees, network design, and more. The idea is to compute some values for a tree rooted at one node and then efficiently recompute the values for the tree rooted at other no
4 min read
Binary Search Tree In Python
A Binary search tree is a binary tree where the values of the left sub-tree are less than the root node and the values of the right sub-tree are greater than the value of the root node. In this article, we will discuss the binary search tree in Python.What is a Binary Search Tree(BST)?A Binary Searc
11 min read
Segment-Tree Module in Python
Prerequisite: Segment Tree Implementation A Segment Tree is a data structure that allows programmers to solve range queries over the given array effectively and to modifying the array values. Basically, Segment Tree is a very flexible and efficient data structure and a large number of problems can b
4 min read
Recurrence Relation in python
Recurrence relation is an equation that recursively defines a sequence, where the next term is a function of the previous terms. Recurrence relations are commonly used to describe the runtime of recursive algorithms in computer science and to define sequences in mathematics. What is a Recurrence Rel
3 min read
Binary Tree in Python
Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves.Introduction to Binary TreeRepresentation of Binar
9 min read
Red Black Tree in Python
Red Black Tree is a self-balancing binary search tree where each node has an extra bit representing its color, either red or black. By constraining how nodes are colored during insertions and deletions, red-black trees ensure the tree remains approximately balanced during all operations, allowing fo
11 min read
B Tree in Python
A B-tree is a self-balancing tree data structure that maintains sorted data and allows searches, sequential access, insertions, and deletions in logarithmic time. B Tree in Python Table of Content Characteristics of B-TreesTraversal of B-Tree in PythonSearch operation in B Tree in PythonInsert opera
14 min read
B+ Tree in Python
In computer science, data structures are crucial in efficiently managing and organizing data. Among these, the B+ tree is a powerful and important data structure, widely used in databases and file systems. In this article, we will discuss the concept of B+ trees, exploring their structure, operation
12 min read
Tree Traversal Techniques in Python
A tree is a non-linear data structure or we can say that it is a type of hierarchical structure. It is like an inverted tree where roots are present at the top and leaf or child nodes are present at the bottom of the tree. The root node and its child nodes are connected through the edges like the br
5 min read