Fix: Remove unused nonlocal/global declarations (F824 errors)

Remove unused nonlocal declarations in find_all_cliques.py and unused
global declaration in construct_tree_postorder_preorder.py to fix
flake8 F824 errors that were causing CI to fail.

These declarations were unnecessary because:
- In find_all_cliques: compsub and solutions are only mutated (append/pop),
  not reassigned, so nonlocal is not needed
- In construct_tree: pre_index is never used or assigned in this function,
  only in construct_tree_util

Also applied black formatting to both files.

Co-Authored-By: Keon <[email protected]>

Author: devin-ai-integration[bot]

algorithms/graph/find_all_cliques.py

@@ -4,6 +4,7 @@
 the subgraph there is an edge between them).
 """
 
+
 def find_all_cliques(edges):
     """
     takes dict of sets
@@ -15,9 +16,7 @@ def find_all_cliques(edges):
     """
 
     def expand_clique(candidates, nays):
-        nonlocal compsub
         if not candidates and not nays:
-            nonlocal solutions
             solutions.append(compsub.copy())
         else:
             for selected in candidates.copy():

algorithms/tree/construct_tree_postorder_preorder.py

@@ -21,87 +21,88 @@
       Output: 8 4 9 2 5 1 6 3 7
 """
 
+
 class TreeNode:
 
-    def __init__(self, val, left = None, right = None):
+    def __init__(self, val, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
 
+
 pre_index = 0
-        
+
+
 def construct_tree_util(pre: list, post: list, low: int, high: int, size: int):
     """
-        Recursive function that constructs tree from preorder and postorder array.
-        
-        preIndex is a global variable that keeps track of the index in preorder
-        array.
-        preorder and postorder array are represented are pre[] and post[] respectively.
-        low and high are the indices for the postorder array.
+    Recursive function that constructs tree from preorder and postorder array.
+
+    preIndex is a global variable that keeps track of the index in preorder
+    array.
+    preorder and postorder array are represented are pre[] and post[] respectively.
+    low and high are the indices for the postorder array.
     """
 
     global pre_index
 
     if pre_index == -1:
         pre_index = 0
-  
-    
-    #Base case
-    if(pre_index >= size or low > high):
+
+    # Base case
+    if pre_index >= size or low > high:
         return None
 
     root = TreeNode(pre[pre_index])
     pre_index += 1
 
-    #If only one element in the subarray return root
-    if(low == high or pre_index >= size):
+    # If only one element in the subarray return root
+    if low == high or pre_index >= size:
         return root
 
-    #Find the next element of pre[] in post[]
+    # Find the next element of pre[] in post[]
     i = low
     while i <= high:
-        if(pre[pre_index] == post[i]):
+        if pre[pre_index] == post[i]:
             break
 
         i += 1
 
-    #Use index of element present in postorder to divide postorder array
-    #to two parts: left subtree and right subtree
-    if(i <= high):
+    # Use index of element present in postorder to divide postorder array
+    # to two parts: left subtree and right subtree
+    if i <= high:
         root.left = construct_tree_util(pre, post, low, i, size)
-        root.right = construct_tree_util(pre, post, i+1, high, size)
+        root.right = construct_tree_util(pre, post, i + 1, high, size)
 
     return root
 
 
 def construct_tree(pre: list, post: list, size: int):
     """
-        Main Function that will construct the full binary tree from given preorder
-        and postorder array.
+    Main Function that will construct the full binary tree from given preorder
+    and postorder array.
     """
 
-    global pre_index
-    root = construct_tree_util(pre, post, 0, size-1, size)
+    root = construct_tree_util(pre, post, 0, size - 1, size)
 
     return print_inorder(root)
 
 
-
-def print_inorder(root: TreeNode, result = None):
+def print_inorder(root: TreeNode, result=None):
     """
-        Prints the tree constructed in inorder format
+    Prints the tree constructed in inorder format
     """
     if root is None:
         return []
-    if result is None: 
+    if result is None:
         result = []
-        
+
     print_inorder(root.left, result)
     result.append(root.val)
     print_inorder(root.right, result)
     return result
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     pre = [1, 2, 4, 5, 3, 6, 7]
     post = [4, 5, 2, 6, 7, 3, 1]
     size = len(pre)