Graph notes and quiz for first half

Author: linkel

6-graphs/GraphNotes.md

@@ -25,3 +25,7 @@ Connectivity, in Graph Theory, indicates the level of connections between nodes.
 A directed graph is weakly connected when only replacing all of the directed edges with undirected edges can cause it to be connected. So if you have a vertex that has an outbound edge but not an inbound edge, and if you replace that edge with a undirected edge it allows connectivity to that vertex, then that graph was weakly connected.
 
 Strongly connected directed graphs have a path from every node to every other node. A to B and B to A. 
+
+### Quiz
+
+Cycles in the provided graph were 3, and it was weakly connected. Odd because I can count 4, so maybe I'm not sure what counts as a cycle?

6-graphs/GraphQuiz-mine.py

@@ -0,0 +1,86 @@
+class Node(object):
+    def __init__(self, value):
+        self.value = value
+        self.edges = []
+
+class Edge(object):
+    def __init__(self, value, node_from, node_to):
+        self.value = value
+        self.node_from = node_from
+        self.node_to = node_to
+
+class Graph(object):
+    def __init__(self, nodes=[], edges=[]):
+        self.nodes = nodes
+        self.edges = edges
+
+    def insert_node(self, new_node_val):
+        new_node = Node(new_node_val)
+        self.nodes.append(new_node)
+        
+    def insert_edge(self, new_edge_val, node_from_val, node_to_val):
+        from_found = None
+        to_found = None
+        for node in self.nodes:
+            if node_from_val == node.value:
+                from_found = node
+            if node_to_val == node.value:
+                to_found = node
+        if from_found == None:
+            from_found = Node(node_from_val)
+            self.nodes.append(from_found)
+        if to_found == None:
+            to_found = Node(node_to_val)
+            self.nodes.append(to_found)
+        new_edge = Edge(new_edge_val, from_found, to_found)
+        from_found.edges.append(new_edge)
+        to_found.edges.append(new_edge)
+        self.edges.append(new_edge)
+
+    def get_edge_list(self):
+        """Don't return a list of edge objects!
+        Return a list of triples that looks like this:
+        (Edge Value, From Node Value, To Node Value)"""
+        edge_list = []
+        for edge in self.edges:
+            edge_list.append((edge.value, edge.node_from.value, edge.node_to.value))
+        return edge_list
+
+    def get_adjacency_list(self):
+        """Don't return any Node or Edge objects!
+        You'll return a list of lists.
+        The indecies of the outer list represent
+        "from" nodes.
+        Each section in the list will store a list
+        of tuples that looks like this:
+        (To Node, Edge Value)"""
+        adjacency_list = [None]*(len(self.nodes)+1)
+        for edge in self.edges:
+            if not adjacency_list[edge.node_from.value]:
+                adjacency_list[edge.node_from.value] = [(edge.node_to.value, edge.value)]
+            else:
+                adjacency_list[edge.node_from.value].append((edge.node_to.value, edge.value))
+        return adjacency_list
+    
+    def get_adjacency_matrix(self):
+        """Return a matrix, or 2D list.
+        Row numbers represent from nodes,
+        column numbers represent to nodes.
+        Store the edge values in each spot,
+        and a 0 if no edge exists."""
+        adjacency_matrix = [[0 for x in range(len(self.nodes)+1)] for y in range(len(self.nodes)+1)]
+        for edge in self.edges:
+            adjacency_matrix[edge.node_from.value][edge.node_to.value] = edge.value
+        return adjacency_matrix
+
+graph = Graph()
+graph.insert_edge(100, 1, 2)
+graph.insert_edge(101, 1, 3)
+graph.insert_edge(102, 1, 4)
+graph.insert_edge(103, 3, 4)
+# Should be [(100, 1, 2), (101, 1, 3), (102, 1, 4), (103, 3, 4)]
+print graph.get_edge_list()
+# Should be [None, [(2, 100), (3, 101), (4, 102)], None, [(4, 103)], None]
+print graph.get_adjacency_list()
+# Should be [[0, 0, 0, 0, 0], [0, 0, 100, 101, 102], [0, 0, 0, 0, 0], [0, 0, 0, 0, 103], [0, 0, 0, 0, 0]]
+print graph.get_adjacency_matrix()

6-graphs/GraphQuiz-solution.py

@@ -0,0 +1,31 @@
+def get_edge_list(self):
+    edge_list = []
+    for edge_object in self.edges:
+        edge = (edge_object.value, edge_object.node_from.value, edge_object.node_to.value)
+        edge_list.append(edge)
+    return edge_list
+
+def get_adjacency_list(self):
+    max_index = self.find_max_index()
+    adjacency_list = [None] * (max_index + 1)
+    for edge_object in self.edges:
+        if adjacency_list[edge_object.node_from.value]:
+            adjacency_list[edge_object.node_from.value].append((edge_object.node_to.value, edge_object.value))
+        else:
+            adjacency_list[edge_object.node_from.value] = [(edge_object.node_to.value, edge_object.value)]
+    return adjacency_list
+
+def get_adjacency_matrix(self):
+    max_index = self.find_max_index()
+    adjacency_matrix = [[0 for i in range(max_index + 1)] for j in range(max_index + 1)]
+    for edge_object in self.edges:
+        adjacency_matrix[edge_object.node_from.value][edge_object.node_to.value] = edge_object.value
+    return adjacency_matrix
+
+def find_max_index(self):
+    max_index = -1
+    if len(self.nodes):
+        for node in self.nodes:
+            if node.value > max_index:
+                max_index = node.value
+    return max_index

6-graphs/GraphRepNotes.md

@@ -0,0 +1,20 @@
+### Edge List
+
+A 2D list that shows a list of edges. It lists the vertices/nodes that are connected to each other. 
+[[0,1],[1,2],[1,3],[2,3]]
+
+### Adjacency List
+
+Each node corresponds to an index in an array. 
+
+0      1        2       3
+[[1],[0,2,3],[1,3],[1,2]]
+
+### Adjacency Matrix
+
+for each node, 1 if connected, 0 if not neighbors. 
+    0  1  2  3
+0    [[0,1,0,0],
+1    [1,0,1,1],
+2    [0,1,0,1],
+3    [0,1,1,0]]