Hierholzer's Algorithm in Python

Introduction:

In this tutorial, we learn about the Hierholzer's algorithm in Python. The basic step of the Hierholzer's algorithm is to combine different circles to form a Euler circle. It starts from a random node. Then, it randomly moves towards neighbours along unvisited edges. Repeat these steps until you reach the starting node. The first circle results in the graph.

In graph theory, Euler's path is the path which visits all edges of a graph exactly once. The Euler path with the same vertical start and end point is the Euler circle, called an Euler diagram. We will use stacking and recursion to search for paths in the Euler diagram. Here, we give the Euler diagram and also print the Euler circuit. The Euler circuit is a path that passes through each graph's edge and ends at the starting vertex. The example is given below -

Example:

Input: For the below graph, the adjacency list is
Output: 0 -> 1 -> 2 -> 3 -> 0 
Input: For the below graph, the adjacency list is
Output: 0 -> 6 -> 4 -> 5 -> 0 -> 1 
         -> 2 -> 3 -> 4 -> 2 -> 0 
Explanation:
In both cases, we can follow the Euler circuit by following the edges shown in the output.

We discussed the problem of determining whether a particular graph represents the Eulerian graph. This tutorial discusses the algorithms for printing Euler orbits or circuits. The same problem can be solved using Fleury's algorithm. However, the complexity of Fleury's algorithm is greater than Hierholzer's algorithm. The time complexity is O(E*E) for Fleury's algorithm. We can find circuits or paths in O(E) using Hierholzer's algorithm, such as linear time. Here is the algorithm: ref (wiki).

Note that a graph has an Euler cycle if (1) all nonzero-degree vertices belong to a connected system. (2) The inner degree and outer degree of each corner are the same. This algorithm assumes that the given graph has an Euler circuit.

We need to choose a starting vertex, v. Then start from that vertex and follow the edge until you return to v. It is impossible to get stuck in a vertex outside v. This happens because when the orbit enters another vertex, then the inner degree and outer degree of each vertex must be the same. Vertex w must have an unused edge w. The tour created this way is a closed tour. But it does not cover the initial graph's vertices and edges.
When there is a vertex u which belongs to the current tour but whose adjacent edges are not part of the tour, start another path from u. It follows the use of edges until it returns to u and joins the tour that way to the previous tour.

So, the goal is to keep track of unused edges and remove them until they get stuck. Once we get stuck, we return to the nearest point on the current path with an unused edge and repeat the process until all edges are used. We can use another container to hold the last and final path:

Now the initial directed graph is given in below
The path will start from 0.
Let, current_path = {0} and circuit = {}
We use the edge 0-1 

Now, current_path = {0,1} and circuit = {}
Now we reach up to 2 and then to 0 again as

Now, current_path = {0,1,2} and circuit = {}
Then we go to 0 and now since 0 has no unused edge, we put 0 in the circuit and go back until we find the edge

We then have current_path = {0,1,2} and circuit = {0}
Similarly, when we return to 2, we cannot find any edge which is unused. So put 2 in circuit and trace backwards.

current_path = {0,1} and circuit = {0,2}

When reaching 1 then we go to through unused edge 1-3, 3-4, 4-1. This process is continued until all edges have been traversed.

The two containers contain are look as:
current_path = {0,1,3,4,1} and circuit = {0,2} 

Now that all edges are used and the current_path is activated one by one.
Now we have this circuit = {0,2,1,4,3,1,0}

To obtain the path, we need to print the circuit, which is reversely
0-1-3-4-1-1-2-0

Program Code:

Now, we are given the program code of Hierholzer's algorithm. Here, we use the Hierholzer algorithm in Python to print the Eulerian circuit in a given directed graph. The code is now given below -

# Here, we use the Hierholzer algorithm in Python to print the Eulerian circuit in the given directed graph 
# Define the function Cir_Print with the parameter adj 
# The adj represents the directed graph's adjacency list
def Cir_Print(adj):
 
    # The number of edges emerging from a vertex is represent by edge_count
    edge_count = dict()
 
    for i in range(len(adj)):
        edge_count[i] = len(adj[i])
 
    if len(adj) == 0:
        return 
# The graph is empty
 
    # Maintain a stack to store vertices
    current_path = []
 
    # Here, we store the final circuit
    circuit = []
 
    # From any vertex you can start
    current_path.append(0)
# Th current vertex intialization
    current_v = 0
 
    while len(current_path):
 
        # If there is any remaining edge
        if edge_count[current_v]:
 
            # The vertex is push here by using this function
            current_path.append(current_v)
 
            # The next vertex finds which is using an edge
            next_v = adj[current_v][-1]
 
            # Here, we remove that edge
            edge_count[current_v] -= 1
            adj[current_v].pop()
 
            # Move to the next vertex from the current vertex
            current_v = next_v
 
        # For finding the remaining circuit we used backtracking method
        else:
            circuit.append(current_v)
 
            # Here, we done the Back-tracking
            current_v = current_path[-1]
            current_path.pop()
 
    # Here, we have got the circuit and print it in reverse
    for i in range(len(circuit) - 1, -1, -1):
        print(circuit[i], end = "")
        if i:
            print(" - ", end = "")
 
# Write the main method of the code
if __name__ == "__main__":
 
    # Declare the input Graph 1
    adj1 = [0] * 4
    for i in range(4):
        adj1[i] = []
 
    # Here, we build the edges for Graph 1
    adj1[0].append(1)
    adj1[1].append(2)
    adj1[2].append(0)
    Cir_Print(adj1)
    print()
 
    # Declare the input Graph 2
    adj2 = [0] * 8
    for i in range(8):
        adj2[i] = []
 # Here, we build the edges for Graph 2
    adj2[0].append(1)
    adj2[1].append(5)
    adj2[1].append(3)
    adj2[2].append(0)
    adj2[2].append(3)
    adj2[3].append(4)
    adj2[4].append(2)
    adj2[4].append(5)
    adj2[5].append(0)
    adj2[6].append(2)
    Cir_Print(adj2)
    print()

Output:

Now, we compile the above code in Python, and after successful compilation, we run it. The output is given below -

0 - 1 - 2 - 0
0 - 1 - 5 - 3 - 4 - 2 - 0 - 3 - 5 - 0

The above code lists the number of edges for each vertex. This is unnecessary since we keep the names side by side anyway. We just removed the creation of the edge_count array. This algorithm replaces 'if edge_count[current_v]' with 'if adj[current_v]'.

The above code pushes the first or initial node into the stack twice. Although we collected the results correctly, the method needed to be clearer and more effective. We eliminate this problem by adding the next vertex into the stack instead of the current vertex. In the part of the testing algorithm, the beginning of the adjacency names "adj1" and "adj2" are slightly different. The potion has also been improved. The improved code is given below.

Program Code:

Now, we are given the improved program code of Hierholzer's algorithm. Here, we use the Hierholzer algorithm in Python to print the Eulerian circuit in a given directed graph. The code is now given below -

# Here we using Hierholzer algorithm in Python for print the Eulerian circuit in given directed graph 
# Define the function Cir_Print with the parameter adj 
# The directed graph's adjacency list is represented by the adj
def Cir_Print(adj):
      
    if len(adj) == 0:
        return # The graph is empty 
  

    # The current_path is used to maintain a stack 
    current_path = [0]
  
    # Here, we store the final circuit
    circuit = []
  
    while current_path:
  
        current_v = current_path[-1]
          
        # If there is remaining edge in adjacency list of the current vertex
        if adj[current_v]:
            next_v = adj[current_v].pop()
  
            # Here, the new vertex is push into the stack
            current_path.append(next_v)
  
        # For find remaining circuit we use backtracking method
        else:
            circuit.append(current_path.pop())
  
    # Here, we have got the circuit and print it in reverse
    for i in range(len(circuit) - 1, -1, -1):
        print(circuit[i], end = "")
        if i:
            print(" - ", end = "")
  
# Write the main method of the code
if __name__ == "__main__":
  
    # Declare the input Graph 1
    adj1 = [[] for _ in range(4)]
  
    # Here, we build the edges for Graph 1
    adj1[0].append(1)
    adj1[1].append(2)
    adj1[2].append(0)
    Cir_Print(adj1)
    print()
  
    # Declare the input Graph 2
    adj2 = [[] for _ in range(8)]
  
   # Here, we build the edges for Graph 2
    adj2[0].append(1)
    adj2[1].append(5)
    adj2[1].append(3)
    adj2[2].append(0)
    adj2[2].append(3)
    adj2[3].append(4)
    adj2[4].append(2)
    adj2[4].append(5)
    adj2[5].append(0)
    adj2[6].append(2)
    Cir_Print(adj2)
    print() 

Output:

Now, we compile the above code in Python, and after successful compilation, we run it. The output is given below -

0 - 1 - 2 - 0
0 - 1 - 5 - 3 - 4 - 2 - 0 - 3 - 5 - 0

Next TopicSelenium Python Introduction and Installation

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

Python Tutorial

Python OOPs

Python MySQL

Python MongoDB

Python SQLite

Python Questions

Plotly

Python Tkinter (GUI)

Python Web Blocker

Python MCQ

Related Tutorials

Python Programs