Adding trees and graphss

binary_search_tree.py

@@ -0,0 +1,102 @@
+
+class Node:
+    def __init__(self, key):
+        self.key = key
+        self.left = None
+        self.right = None
+
+# Inorder traversal
+def inorder(root):
+    if root is not None:
+        # Traverse left
+        inorder(root.left)
+
+        # Traverse root
+        print(str(root.key) + "->", end=' ')
+
+        # Traverse right
+        inorder(root.right)
+
+
+# Insert a node
+def insert(node, key):
+
+    # Return a new node if the tree is empty
+    if node is None:
+        return Node(key)
+
+    # Traverse to the right place and insert the node
+    if key < node.key:
+        node.left = insert(node.left, key)
+    else:
+        node.right = insert(node.right, key)
+
+    return node
+
+
+# Find the inorder successor
+def minValueNode(node):
+    current = node
+
+    # Find the leftmost leaf
+    while(current.left is not None):
+        current = current.left
+
+    return current
+
+
+# Deleting a node
+def deleteNode(root, key):
+
+    # Return if the tree is empty
+    if root is None:
+        return root
+
+    # Find the node to be deleted
+    if key < root.key:
+        root.left = deleteNode(root.left, key)
+    elif(key > root.key):
+        root.right = deleteNode(root.right, key)
+    else:
+        # If the node is with only one child or no child
+        if root.left is None:
+            temp = root.right
+            root = None
+            return temp
+
+        elif root.right is None:
+            temp = root.left
+            root = None
+            return temp
+
+        # If the node has two children,
+        # place the inorder successor in position of the node to be deleted
+        temp = minValueNode(root.right)
+
+        root.key = temp.key
+
+        # Delete the inorder successor
+        root.right = deleteNode(root.right, temp.key)
+
+    return root
+
+
+root = None
+root = insert(root, 9)
+root = insert(root, 3)
+root = insert(root, 2)
+root = insert(root, 4)
+root = insert(root, 7)
+root = insert(root, 10)
+root = insert(root, 15)
+root = insert(root, 5)
+
+print("Inorder traversal: ", end=' ')
+inorder(root)
+
+print("\nDelete 10")
+root = deleteNode(root, 10)
+
+print("Inorder traversal: ", end=' ')
+inorder(root)
+    

binary_tree.py

@@ -0,0 +1,46 @@
+
+class Node:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+    # Traverse preorder
+    def traversePreOrder(self):
+        print(self.val, end=' ')
+        if self.left:
+            self.left.traversePreOrder()
+        if self.right:
+            self.right.traversePreOrder()
+
+    # Traverse inorder
+    def traverseInOrder(self):
+        if self.left:
+            self.left.traverseInOrder()
+        print(self.val, end=' ')
+        if self.right:
+            self.right.traverseInOrder()
+
+    # Traverse postorder
+    def traversePostOrder(self):
+        if self.left:
+            self.left.traversePostOrder()
+        if self.right:
+            self.right.traversePostOrder()
+        print(self.val, end=' ')
+
+
+root = Node(5)
+
+root.left = Node(6)
+root.right = Node(7)
+
+root.left.left = Node(8)
+
+print("Preorder Traversal: ", end="")
+root.traversePreOrder()
+print("\nInorder Traversal: ", end="")
+root.traverseInOrder()
+print("\nPostorder Traversal: ", end="")
+root.traversePostOrder()
+    

graph.py

@@ -0,0 +1,40 @@
+class Graph:
+    def __init__(self):
+        self.graph = {}
+        
+    def add_vertex(self, vertex):
+        if vertex not in self.graph:
+            self.graph[vertex] = []
+        else:
+            print(f"Vertex {vertex} already exists.")
+            
+    def add_edge(self, vertex1, vertex2, length:int):
+        if vertex1 in self.graph and vertex2 in self.graph:
+            self.graph[vertex1].append(vertex2)
+            self.graph[vertex2].append(vertex1)
+            self.length = length
+        else:
+            print("One or both vertices not found.")
+    
+    def display(self):
+        for vertex in self.graph:
+            print(f'{vertex}: {self.graph[vertex]} : {self.length}' )
+
+# Example usage
+if __name__ == "__main__":
+    g = Graph()
+    
+    # Adding vertices
+    g.add_vertex("A")
+    g.add_vertex("B")
+    g.add_vertex("C")
+    g.add_vertex("D")
+    
+    # Adding edges
+    g.add_edge("A", "B", 10)
+    g.add_edge("A", "C", 5)
+    g.add_edge("B", "D", 30)
+    g.add_edge("C", "D", 11)
+    
+    # Display the graph
+    g.display()

graph_with_edge_lengths.py

@@ -0,0 +1,90 @@
+import heapq
+
+class Graph:
+    def __init__(self):
+        self.graph = {}              # adjacency list
+        self.edge_lengths = {}       # edge length dictionary
+
+    def add_vertex(self, vertex):
+        if vertex not in self.graph:
+            self.graph[vertex] = []
+        else:
+            print(f"Vertex {vertex} already exists.")
+
+    def add_edge(self, vertex1, vertex2, length: float):
+        if vertex1 in self.graph and vertex2 in self.graph:
+            self.graph[vertex1].append(vertex2)
+            self.graph[vertex2].append(vertex1)
+            # Store edge length using a frozenset to avoid duplicates
+            self.edge_lengths[frozenset([vertex1, vertex2])] = length
+        else:
+            print("One or both vertices not found.")
+
+    def display(self):
+        print("Adjacency List:")
+        for vertex in self.graph:
+            print(f'{vertex}: {self.graph[vertex]}')
+        print("\nEdge Lengths:")
+        for edge, length in self.edge_lengths.items():
+            v1, v2 = tuple(edge)
+            print(f'{v1} - {v2}: {length}')
+            
+
+    def dijkstra(self, start, end):
+        distances = {vertex: float('inf') for vertex in self.graph}
+        distances[start] = 0
+        previous = {vertex: None for vertex in self.graph}
+        queue = [(0, start)]
+
+        while queue:
+            current_distance, current_vertex = heapq.heappop(queue)
+
+            if current_vertex == end:
+                break
+
+            for neighbor in self.graph[current_vertex]:
+                edge = frozenset([current_vertex, neighbor])
+                weight = self.edge_lengths.get(edge, float('inf'))
+                distance = current_distance + weight
+
+                if distance < distances[neighbor]:
+                    distances[neighbor] = distance
+                    previous[neighbor] = current_vertex
+                    heapq.heappush(queue, (distance, neighbor))
+
+        # Reconstruct path
+        path = []
+        current = end
+        while current:
+            path.insert(0, current)
+            current = previous[current]
+
+        print(f"Shortest path from {start} to {end}: {' -> '.join(path)} with length {distances[end]}")
+            
+# Example usage
+g = Graph()
+
+# City node abbreviations
+A = "San Tan Valley"
+B = "Phoenix"
+C = "Globe"
+D = "Mesa"
+E = "Florence"
+
+# Adding nodes to graph
+g.add_vertex(A)
+g.add_vertex(B)
+g.add_vertex(C)
+g.add_vertex(D)
+g.add_vertex(E)
+
+# Adding edges to graph
+g.add_edge(A, B, 34)
+g.add_edge(A, C, 47)
+g.add_edge(B, D, 18.8)
+g.add_edge(C, D, 13)
+g.add_edge(B, E, 63)
+
+g.display()
+g.dijkstra(A, D)
+