Detect Cycle in Undirected Graph using BFS in Python

This is a Python program to find if an undirected graph contains a cycle using BFS.

Problem Description

The program creates a graph object and allows the user to determine whether the graph contains a cycle.

Problem Solution

1. Create classes for Graph, Vertex and Queue.
2. Create a function is_cycle_present that takes a Vertex object v and a set visited as arguments.
3. The function begins by creating an empty set called visited and a Queue object q.
4. It also creates a dictionary parent which maps each vertex to its parent in the BFS tree. v is mapped to None.
5. It enqueues v and also adds it to the set visited.
6. A while loop is created which runs as long as the queue is not empty.
7. In each iteration of the loop, the queue is dequeued and all of its neighbours are enqueued which have not already been visited.
8. In addition to enqueuing, they are also added to the set visited and the parent of each neighbour is set to the dequeued node.
9. If a neighbour is found to be already visited, it is checked if the parent of the dequeued element is that neighbour. If it is not, the graph contains a cycle and True is returned.
10. After the loop is finished, False is returned to indicate no cycle is present.
11. Thus, the function returns True if there is a cycle in the connected component containing v. It also puts all nodes reachable from the source vertex in the set visited.

Program/Source Code

Here is the source code of a Python program to find if an undirected graph contains a cycle using BFS. The program output is shown below.

class Graph:
    def __init__(self):
        # dictionary containing keys that map to the corresponding vertex object
        self.vertices = {}
 
    def add_vertex(self, key):
        """Add a vertex with the given key to the graph."""
        vertex = Vertex(key)
        self.vertices[key] = vertex
 
    def get_vertex(self, key):
        """Return vertex object with the corresponding key."""
        return self.vertices[key]
 
    def __contains__(self, key):
        return key in self.vertices
 
    def add_edge(self, src_key, dest_key, weight=1):
        """Add edge from src_key to dest_key with given weight."""
        self.vertices[src_key].add_neighbour(self.vertices[dest_key], weight)
 
    def add_undirected_edge(self, v1_key, v2_key, weight=1):
        """Add undirected edge (2 directed edges) between v1_key and v2_key with
        given weight."""
        self.add_edge(v1_key, v2_key, weight)
        self.add_edge(v2_key, v1_key, weight)
 
    def does_undirected_edge_exist(self, v1_key, v2_key):
        """Return True if there is an undirected edge between v1_key and v2_key."""
        return (self.does_edge_exist(v1_key, v2_key)
                and self.does_edge_exist(v1_key, v2_key))
 
    def does_edge_exist(self, src_key, dest_key):
        """Return True if there is an edge from src_key to dest_key."""
        return self.vertices[src_key].does_it_point_to(self.vertices[dest_key])
 
    def __iter__(self):
        return iter(self.vertices.values())
 
 
class Vertex:
    def __init__(self, key):
        self.key = key
        self.points_to = {}
 
    def get_key(self):
        """Return key corresponding to this vertex object."""
        return self.key
 
    def add_neighbour(self, dest, weight):
        """Make this vertex point to dest with given edge weight."""
        self.points_to[dest] = weight
 
    def get_neighbours(self):
        """Return all vertices pointed to by this vertex."""
        return self.points_to.keys()
 
    def get_weight(self, dest):
        """Get weight of edge from this vertex to dest."""
        return self.points_to[dest]
 
    def does_it_point_to(self, dest):
        """Return True if this vertex points to dest."""
        return dest in self.points_to
 
 
class Queue:
    def __init__(self):
        self.items = []
 
    def is_empty(self):
        return self.items == []
 
    def enqueue(self, data):
        self.items.append(data)
 
    def dequeue(self):
        return self.items.pop(0)
 
 
def is_cycle_present(vertex, visited):
    """Return True if cycle is present in component containing vertex and put
    all vertices in component in set visited."""
    parent = {vertex: None}
    q = Queue()
    q.enqueue(vertex)
    visited.add(vertex)
    while not q.is_empty():
        current = q.dequeue()
        for dest in current.get_neighbours():
            if dest not in visited:
                visited.add(dest)
                parent[dest] = current
                q.enqueue(dest)
            else:
                if parent[current] is not dest:
                    return True
    return False
 
 
g = Graph()
print('Undirected Graph')
print('Menu')
print('add vertex <key>')
print('add edge <vertex1> <vertex2>')
print('cycle')
print('display')
print('quit')
 
while True:
    do = input('What would you like to do? ').split()
 
    operation = do[0]
    if operation == 'add':
        suboperation = do[1]
        if suboperation == 'vertex':
            key = int(do[2])
            if key not in g:
                g.add_vertex(key)
            else:
                print('Vertex already exists.')
        elif suboperation == 'edge':
            v1 = int(do[2])
            v2 = int(do[3])
            if v1 not in g:
                print('Vertex {} does not exist.'.format(v1))
            elif v2 not in g:
                print('Vertex {} does not exist.'.format(v2))
            else:
                if not g.does_undirected_edge_exist(v1, v2):
                    g.add_undirected_edge(v1, v2)
                else:
                    print('Edge already exists.')
 
    elif operation == 'cycle':
        present = False
        visited = set()
        for v in g:
            if v not in visited:
                if is_cycle_present(v, visited):
                    present = True
                    break
 
        if present:
            print('Cycle present.')
        else:
            print('Cycle not present.')
 
    elif operation == 'display':
        print('Vertices: ', end='')
        for v in g:
            print(v.get_key(), end=' ')
        print()
 
        print('Edges: ')
        for v in g:
            for dest in v.get_neighbours():
                w = v.get_weight(dest)
                print('(src={}, dest={}, weight={}) '.format(v.get_key(),
                                                             dest.get_key(), w))
        print()
 
    elif operation == 'quit':
        break
Program Explanation

1. An instance of Graph is created.
2. A menu is presented to the user to perform various operations on the graph.
3. To determine whether the graph contains a cycle, is_cycle_present is called with a vertex from the graph and an empty set visited.
4. If is_cycle_present returns True, a cycle is present. Otherwise, if not all vertices were visited, is_cycle_present is called again with an unvisited source vertex.
5. This continues until all vertices have been visited or is_cycle_present returns True.
6. If all vertices have been visited, then there are no cycles in the graph.

advertisement
advertisement
Runtime Test Cases
Case 1:
Undirected Graph
Menu
add vertex <key>
add edge <vertex1> <vertex2>
cycle
display
quit
What would you like to do? add vertex 1
What would you like to do? add vertex 2
What would you like to do? add edge 1 2
What would you like to do? cycle
Cycle not present.
What would you like to do? add vertex 3
What would you like to do? add edge 2 3
What would you like to do? cycle
Cycle not present.
What would you like to do? add edge 3 1
What would you like to do? cycle
Cycle present.
What would you like to do? quit
 
Case 2:
Undirected Graph
Menu
add vertex <key>
add edge <vertex1> <vertex2>
cycle
display
quit
What would you like to do? add vertex 1
What would you like to do? add vertex 2
What would you like to do? add vertex 3
What would you like to do? add vertex 4
What would you like to do? add vertex 5
What would you like to do? add vertex 6
What would you like to do? add edge 1 2
What would you like to do? add edge 1 3
What would you like to do? add edge 2 4
What would you like to do? add edge 2 5
What would you like to do? add edge 6 5
What would you like to do? cycle
Cycle not present.
What would you like to do? add edge 6 2
What would you like to do? cycle
Cycle present.
What would you like to do? quit

Sanfoundry Global Education & Learning Series – Python Programs.

To practice all Python programs, here is complete set of 150+ Python Problems and Solutions.

advertisement
advertisement
Subscribe to our Newsletters (Subject-wise). Participate in the Sanfoundry Certification contest to get free Certificate of Merit. Join our social networks below and stay updated with latest contests, videos, internships and jobs!

Youtube | Telegram | LinkedIn | Instagram | Facebook | Twitter | Pinterest
Manish Bhojasia - Founder & CTO at Sanfoundry
Manish Bhojasia, a technology veteran with 20+ years @ Cisco & Wipro, is Founder and CTO at Sanfoundry. He lives in Bangalore, and focuses on development of Linux Kernel, SAN Technologies, Advanced C, Data Structures & Alogrithms. Stay connected with him at LinkedIn.

Subscribe to his free Masterclasses at Youtube & discussions at Telegram SanfoundryClasses.