Create app.py

app.py

@@ -0,0 +1,126 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+import networkx as nx
+
+# Node class for tree structures
+class Node:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+# Function to insert nodes in a binary search tree
+def insert(root, key):
+    if root is None:
+        return Node(key)
+    if key < root.val:
+        root.left = insert(root.left, key)
+    else:
+        root.right = insert(root.right, key)
+    return root
+
+# Function to perform inorder traversal
+def inorder(root):
+    return inorder(root.left) + [root.val] + inorder(root.right) if root else []
+
+# Function to perform preorder traversal
+def preorder(root):
+    return [root.val] + preorder(root.left) + preorder(root.right) if root else []
+
+# Function to perform postorder traversal
+def postorder(root):
+    return postorder(root.left) + postorder(root.right) + [root.val] if root else []
+
+# Function to perform level order traversal
+def level_order(root):
+    result = []
+    if root is None:
+        return result
+    queue = [root]
+    while queue:
+        node = queue.pop(0)
+        result.append(node.val)
+        if node.left:
+            queue.append(node.left)
+        if node.right:
+            queue.append(node.right)
+    return result
+
+# Function to visualize the tree using networkx and matplotlib
+def visualize_tree(root):
+    graph = nx.DiGraph()
+    def add_edges(node, pos=None):
+        if node is not None:
+            graph.add_node(node.val)
+            if pos is not None:
+                graph.add_edge(pos, node.val)
+            add_edges(node.left, node.val)
+            add_edges(node.right, node.val)
+    add_edges(root)
+    
+    plt.figure(figsize=(10, 6))
+    pos = hierarchy_pos(graph, root.val)
+    nx.draw(graph, pos, with_labels=True, node_size=5000, node_color="skyblue", font_size=16, font_weight="bold", font_color="black")
+    plt.show()
+
+def hierarchy_pos(G, root=None, width=1., vert_gap = 0.2, vert_loc = 0, xcenter = 0.5):
+    pos = _hierarchy_pos(G, root, width, vert_gap, vert_loc, xcenter)
+    return pos
+
+def _hierarchy_pos(G, root, width=1., vert_gap = 0.2, vert_loc = 0, xcenter = 0.5, pos=None, parent=None, parsed=[]):
+    if pos is None:
+        pos = {root: (xcenter, vert_loc)}
+    else:
+        pos[root] = (xcenter, vert_loc)
+    children = list(G.neighbors(root))
+    if not isinstance(G, nx.DiGraph) and parent is not None:
+        children.remove(parent)  
+    if len(children) != 0:
+        dx = width / len(children) 
+        nextx = xcenter - width/2 - dx/2 
+        for child in children:
+            nextx += dx
+            pos = _hierarchy_pos(G, child, width=dx, vert_gap=vert_gap, vert_loc=vert_loc-vert_gap, xcenter=nextx, pos=pos, parent=root, parsed=parsed)
+    return pos
+
+def perform_tree_operations(values, operation):
+    root = None
+    for value in values:
+        root = insert(root, value)
+    
+    if operation == "Inorder Traversal":
+        result = inorder(root)
+    elif operation == "Preorder Traversal":
+        result = preorder(root)
+    elif operation == "Postorder Traversal":
+        result = postorder(root)
+    elif operation == "Level Order Traversal":
+        result = level_order(root)
+    elif operation == "Visualize Tree":
+        visualize_tree(root)
+        return "Tree Visualization"
+    
+    return result
+
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("## Tree Operations Visualization")
+
+    with gr.Row():
+        with gr.Column():
+            input_values = gr.Textbox(label="Enter Values (comma-separated)", placeholder="e.g., 10, 20, 5, 15, 25")
+            operation = gr.Radio(choices=["Inorder Traversal", "Preorder Traversal", "Postorder Traversal", "Level Order Traversal", "Visualize Tree"], label="Select Operation")
+            submit = gr.Button("Submit")
+        
+        with gr.Column():
+            output = gr.Textbox(label="Output", lines=4)
+            graph_output = gr.Plot(label="Tree Visualization")
+
+    def on_submit(values, operation):
+        values = list(map(int, values.split(',')))
+        result = perform_tree_operations(values, operation)
+        return str(result)
+
+    submit.click(on_submit, inputs=[input_values, operation], outputs=[output, graph_output])
+
+demo.launch()