Question

1. Code a breadth First traversal.

2. Code a depth First traversal.

Note, your traversals should return a string listing the nodes added to the min spanning tree and the order they are added.

Using Python.

Starter code:

from collections import deque

class Edge:
    def __init__(self, endIndex, next = None):
        self.endIndex = endIndex
        self.next = next

class Node:
    def __init__(self, name):
        self.name = name
        self.visited = False
        self.connects = None
        
class Graph:
    def __init__(self):
        self.nodeList = []
        self.size = 20
        self.numNodes = 0
        self.edgeMatrix = []
        for i in range(self.size):
            self.edgeMatrix.append([])
            for j in range(self.size):
                self.edgeMatrix[i].append(0)
                
                
    def addNode(self,name):

        if self.numNodes >= self.size:
            return False
        

        if self.findNode(name) != -1:
            return False
        

        temp = Node(name)
        self.nodeList.append(temp)
        self.numNodes += 1
        return True
        
        
    def addEdge(self, starts, ends):

        if starts == ends:
            return False
        
        startIndex = self.findNode(starts)
        endIndex = self.findNode(ends)
        

        if startIndex == -1 or endIndex == -1:
            return False
        

        self.edgeMatrix[startIndex][endIndex] = 1
        self.edgeMatrix[endIndex][startIndex] = 1
        

        startEnd = Edge(endIndex)
        startEnd.next = self.nodeList[startIndex].connects
        self.nodeList[startIndex].connects = startEnd
        
        endStart = Edge(startIndex)
        endStart.next = self.nodeList[endIndex].connects
        self.nodeList[endIndex].connects = endStart
        
        return True
    
    
    def findNode(self, name):
        for index in range(self.numNodes):
            if self.nodeList[index].name == name:
                return index

        return -1
    
    
    def listNodes(self):
        nodes = "The Nodes are: "
        
        for index in range(self.numNodes):
            nodes += self.nodeList[index].name
            if index != self.numNodes - 1:
                nodes += ", "
                
        return nodes
    
    
    def displayEdges(self):
        edges = "The EdgeList is: (Node: its edges)\n"
        

        for index in range(self.numNodes):
            
            edges += self.nodeList[index].name
            edges += ": "
            
            ptr = self.nodeList[index].connects
            while ptr:
                edges += self.nodeList[ptr.endIndex].name
                edges += " "
                ptr = ptr.next
                
            edges += "\n"
            
        return edges
        
        
    def displayMatrix(self):
        matrix = "The edgeMatrix is: \n  "
         
        for index in range(self.numNodes):
            matrix += self.nodeList[index].name
            matrix += "   "
            
        matrix += "\n"
        
        for index1 in range(self.numNodes):
            matrix += self.nodeList[index1].name
            matrix += "   "
            
            for index2 in range(self.numNodes):
                matrix += str(self.edgeMatrix[index1][index2])
                matrix += "   "
                
            matrix += "\n"
            
        return matrix
    
    def resetVisited(self):
        for index in range(self.numNodes):
            self.nodeList[index].visited = False
            
            
     # create a min tree with depthFirst Traversal starting at a given node
     # then lists non-reachable nodes
    def depthFirst(self, name):
        tree = "Depth First Traversal starting at " + name + "\n"
        
        return tree + "\n"
    
    def breadthFirst(self, name):
        tree = "Breadth First Traversal starting at " + name + "\n"

        return tree + "\n"

Driver:

from NonDirectedGraph import Graph


def main():
          
    #define tree
    
    tree = Graph()
   
    tree.addNode('A')
    tree.addNode('C')
    tree.addNode('T')
    tree.addNode('Z')
    tree.addNode('X')
    tree.addNode('K')
    tree.addNode('Q')
    tree.addNode('J')
    tree.addNode('M')
    tree.addNode('U')

    print(tree.listNodes(), end = "\n")
         
    tree.addEdge('A', 'C')
    tree.addEdge('A', 'T')
    tree.addEdge('A', 'Z')
    tree.addEdge('X', 'C')
    tree.addEdge('C', 'K')
    tree.addEdge('T', 'Q')
    tree.addEdge('K', 'Q')
    tree.addEdge('Q', 'J')
    tree.addEdge('J', 'M')
    tree.addEdge('Z', 'X')

    print(tree.displayEdges(), end = "\n")
    
    print(tree.displayMatrix(), end = "\n")
    
    print(tree.breadthFirst('Q'), end = "\n")
    
    print(tree.depthFirst('Q'), end = "\n")

    
if __name__ == '__main__':
    main()

Answer 1

Breadth First Search Traversal -

# Python3 Program to print BFS traversal
# from a given source vertex. BFS(int s)
# traverses vertices reachable from s.
from collections import defaultdict
  
# This class represents a directed graph
# using adjacency list representation
class Graph:
  
# Constructor
def __init__(self):
  
# default dictionary to store graph
self.graph = defaultdict(list)
  
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
  
# Function to print a BFS of graph
def BFS(self, s):
  
# Mark all the vertices as not visited
visited = [False] * (len(self.graph))
  
# Create a queue for BFS
queue = []
  
# Mark the source node as
# visited and enqueue it
queue.append(s)
visited[s] = True
  
while queue:
  
# Dequeue a vertex from
# queue and print it
s = queue.pop(0)
print (s, end = " ")
  
# Get all adjacent vertices of the
# dequeued vertex s. If a adjacent
# has not been visited, then mark it
# visited and enqueue it
for i in self.graph[s]:
if visited[i] == False:
queue.append(i)
visited[i] = True
  
# Driver code
  
# Create a graph given in
# the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
  
print ("Following is Breadth First Traversal"
" (starting from vertex 2)")
g.BFS(2)

Depth First Search Traversal -

# Python program to print DFS traversal from a
# given given graph
from collections import defaultdict
  
# This class represents a directed graph using
# adjacency list representation
class Graph:
  
# Constructor
def __init__(self):
  
# default dictionary to store graph
self.graph = defaultdict(list)
  
# function to add an edge to graph
def addEdge(self,u,v):
self.graph[u].append(v)
  
# A function used by DFS
def DFSUtil(self,v,visited):
  
# Mark the current node as visited and print it
visited[v]= True
print v,
  
# Recur for all the vertices adjacent to this vertex
for i in self.graph[v]:
if visited[i] == False:
self.DFSUtil(i, visited)
  
  
# The function to do DFS traversal. It uses
# recursive DFSUtil()
def DFS(self,v):
  
# Mark all the vertices as not visited
visited = [False]*(len(self.graph))
  
# Call the recursive helper function to print
# DFS traversal
self.DFSUtil(v,visited)
  
  
# Driver code
# Create a graph given in the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)
  
print "Following is DFS from (starting from vertex 2)"
g.DFS(2)