Decoding Disjoint Sets in Python: A Comprehensive Overview


Disjoint Sets is a data structure used to maintain a collection of disjoint sets, where each element belongs to only one set. It is a crucial concept in computer science and has many practical applications.

This article will provide an in-depth overview of the basics of Disjoint Sets, how it works, and its optimization techniques using Python code. It will also cover its real-world applications such as Kruskal’s Algorithm for Minimum Spanning Tree (MST) and Connected Components in Graphs.

Explanation of Disjoint Sets

Disjoint Sets can be understood as a group of sets with no overlapping elements. In other words, each element belongs to only one set and no more. The main operations performed on Disjoint Sets are Union, Find, and MakeSet operations.

The Union operation merges two sets into one by finding their parent roots. The Find operation determines which set an element belongs to by returning the root parent of that particular element’s set.

The MakeSet operation creates a new set that contains only one element. Disjoint Set data structures are implemented using an array-based approach or linked-list-based approach where each node represents an element or a set.

Importance of Disjoint Sets in Computer Science

Disjoint Sets have broad applications in many areas of computer science such as network connectivity algorithms, clustering problems, graph algorithms like Kruskal’s Algorithm for Minimum Spanning Tree (MST), image segmentation, compiler optimizations and much more. For instance, Kruskal’s Algorithm solves the minimum-spanning-tree problem that finds the linking path between multiple nodes with minimal weight or cost. It is based on applying Union-Find operations on edges from different sets obtained from sorting all edges based on their weight.

this article will take you through a comprehensive overview of Disjoint Sets, its operations, implementation strategies and optimization techniques used in Python programming language. It will also cover practical applications of Disjoint Sets in solving real-world problems.

Basic Concepts of Disjoint Sets

Disjoint sets refer to a data structure that deals with a set of elements partitioned into non-overlapping subsets. Each subset is called a disjoint set, and the elements within it are said to belong to the same set.

The concept of disjoint sets is fundamental in computer science, as it is used extensively in various algorithms and applications. Understanding the basic concepts of disjoint sets is therefore crucial.

Definition and Characteristics of Disjoint Sets

A disjoint set system consists of a collection S of n elements which are partitioned into one or more non-empty sets. The partitioning implies that each element belongs to only one subset at any given time (i.e., there are no overlapping subsets). Each subset has an arbitrary representative element chosen from that subset, which makes it easy to identify and compare different subsets.

The key characteristics of disjoint sets include the ability to perform union operations between two subsets (which merge them into a single subset), find operations (which identify which subset an element belongs to), and make-set operations (which initialize an empty set consisting of one element). These operations form the building blocks for more complex algorithms based on disjoint sets.

Operations on Disjoint Sets: Union, Find, MakeSet

The three primary operations performed on disjoint sets are union, find, and make-set. The union operation combines two subsets into a single larger subset.

More specifically, it takes two elements from separate subsets and merges them into a single subset. The find operation identifies which subset an element belongs to by searching through all existing subsets until it finds the correct one.

Make-set initializes an empty set consisting of one element. In Python programming language implementations where arrays or linked lists are used as data structures for implementing disjoint sets data structures,

union(x,y) consists of the following steps:

  1. Find the representative element (root) of the two subsets containing x and y.
  2. If both the elements have different roots, then merge them by making one root a child of another.

Similarly, find(x) operation involves traversing through the parent nodes until a root representative is encountered while makeset(x) involves creating an array or linked list with a single element “x” and updating its parent node to be itself.

Implementation using Arrays and Linked Lists

In Python implementation of disjoint sets using arrays, each element corresponds to an index in the array. Each index stores information about its parent node.

Initially, every element’s parent node is set to itself (i.e., it forms its subset). In contrast, LinkedList implementation involves creating n linked lists consisting a single node only initially such that each element belongs to exactly one list representing one subset.

These subsets are later combined using union operations to form larger disjoint sets. The efficiency of these implementations varies according to their complexity in terms of time and space required for different operations with arrays being more efficient in terms of memory usage while linked lists are more efficient during union operations.

Optimizing Disjoint Set Operations

The Path Compression Technique: Striving for Efficiency

When it comes to disjoint sets, one of the primary areas for optimization is with the Find operation. Without any optimizations, Find can become time-intensive, especially with larger datasets. One way to significantly reduce the time complexity of Find is by utilizing the Path Compression Technique.

The idea behind Path Compression is simple; it compresses the path between each node and its root by making each node in that path point directly to the root. By doing so, we are effectively reducing the length of each path and improving our algorithm’s efficiency.

Visually, this technique means that after we find a node’s root using Find(), we make sure that all nodes on the path have their parent set as it’s root. This way, we optimize future searches as these new paths are shorter than before.

How do you implement Path Compression using Python?

Here’s a quick example of implementing Path Compression in Python: “` def find(x): if parent[x]!=x:

parent[x] = find(parent[x]) return parent[x] “`

As shown above in our implementation of Find(), when we recurse through each level and encounter a non-root element, we point it directly to its root to achieve compression. The code above checks if x isn’t equal to its parent; if so, then it recursively assigns x’s parent as its grandparent until x finds its corresponding root element.

What’s the Time Complexity Analysis?

With path compression implemented in your Disjoint Sets algorithm, searches become incredibly fast! The expected amortized time complexity for both Union and Find drops down to O(alpha(n)), where alpha(n) represents an inverse function of an incredibly slow-growing sequence known as Ackermann’s function. In other words- incredible speedup!

The Union by Rank Technique: Better Union with a Smarter Approach

The second optimization technique for Disjoint Sets is the Union by Rank technique. Initially developed as part of the Disjoint Set Forest algorithm, this approach aims to optimize the Union operation’s time complexity.

The basic idea behind this technique is simple: It keeps track of each set’s rank (analogous to its size) and performs union operations by attaching the shorter tree below the taller one. By doing so, we prevent our Disjoint Sets structure from becoming unbalanced.

How do you implement Union by Rank using Python?

Here’s an example of how you could implement Union by Rank in Python: “` def union(x,y): x_parent = find(x)

y_parent = find(y) if x_parent == y_parent:

return if rank[x_parent] < rank[y_parent]:

parent[x_parent] = y_parent rank[y_parent] += rank[x_parent]

else: parent[y_parent] = x_parent

rank[x_parent] += rank[y.parent] “` In our implementation above, we first find the roots of their respective sets and compare them.

If they are already in the same set, there is no need to perform any further operations. Otherwise, we attach one set with a lower-rank as a child to another set with higher-rank.

What’s The Time Complexity Analysis?

Using this approach, we can guarantee that each tree in our Disjoint Set structure has an average depth at most O(log(n)). When combining both Union and Find Operations, again using amortized analysis techniques -Union by Rank Technique gives us an expected time complexity of O(alpha(n)) – which is equal to that of Path Compression Technique.

Applications of Disjoint Sets in Real-World Scenarios

Disjoint sets have a wide range of applications in computer science, including graph algorithms such as Kruskal’s algorithm for constructing minimum spanning trees. The algorithm is used to find the shortest possible path that connects all the vertices in an undirected weighted graph. This algorithm relies on disjoint sets to determine which edges should be added to the minimum spanning tree.

Kruskal’s Algorithm for Minimum Spanning Tree (MST)

Kruskal’s algorithm is a greedy algorithm that builds a minimum spanning tree from an undirected graph. The basic idea behind this algorithm is to sort all the edges of the given graph in descending order based on their weights and then add them one by one to the growing minimum spanning tree, while ensuring that no cycle is formed. The algorithm starts with creating a new set for each vertex of the graph.

Then, it sorts all edges by their weight and iterates over them. In each iteration, if both vertices connected by this edge belong to different sets, then these two sets are merged into one and this edge is added to the minimum spanning tree.

Implementation using Python Code

Here’s an implementation of Kruskal’s Algorithm using disjoint set data structure: “` class DisjointSet: def __init__(self, n):

self.parent = [i for i in range(n)] self.rank = [0] * n

def find(self, x): if x != self.parent[x]:

self.parent[x] = self.find(self.parent[x]) return self.parent[x]

def union(self, x_root, y_root): if x_root == y_root:

return if rank[x_root] < rank[y_root]:

parent[x_root] = y_root elif rank[y_root] < rank[x_root]:

parent[y_root] = x_root else:

parent[y_root] = x_root rank[x_root] += 1

def kruskalMST(graph, V): dsu = DisjointSet(V)

edges = [] for u in range(V):

for v in graph[u]: edges.append([graph[u][v], u, v])

edges.sort() result = []

for w, u, v in edges: u_rep, v_rep = dsu.find(u), dsu.find(v)

if u_rep != v_rep: result.append([w,u,v])

dsu.union(u_rep,v_rep) return result “`

Time Complexity Analysis

The time complexity of Kruskal’s algorithm is O(E log E) where E is the number of edges in the graph. Sorting all the edges and then iterating over them takes O(E log E) time. The find and union operations on disjoint sets take almost constant time (amortized O(α(n))), where α(n) is the inverse Ackermann function.

Connected Components in Graphs

A connected component of an undirected graph is a subgraph in which there is a path between every pair of vertices. A graph can have multiple connected components, and disjoint sets can be used to compute them efficiently.

Explanation and Visualization

To find connected components using disjoint sets, we need to keep track of which vertices are connected to each other. We start by creating a new set for each vertex of the graph.

Then we iterate over all the edges and merge their corresponding sets using union operation if they are not already merged. After iterating over all the edges, we have multiple disjoint sets that represent different connected components of our graph.

Implementation using Python Code

Here’s a simple implementation of finding connected components using disjoint set data structure: “` class DisjointSet: def __init__(self, n):

self.parent = [i for i in range(n)] self.rank = [0] * n

def find(self, x): if x != self.parent[x]:

self.parent[x] = self.find(self.parent[x]) return self.parent[x]

def union(self, x_root, y_root): if x_root == y_root:

return if rank[x_root] < rank[y_root]:

parent[x_root] = y_root elif rank[y_root] < rank[x_root]:

parent[y_root] = x_root else:

parent[y_root] = x_root rank[x_root] += 1

def getConnectedComponents(graph, V): dsu = DisjointSet(V)

for u in range(V): for v in graph[u]:

dsu.union(u,v) components = {}

for i in range(V): root_i = dsu.find(i)

if root_i not in components: components[root_i] = []

components[root_i].append(i) return list(components.values()) “`

Time Complexity Analysis

The time complexity of finding connected components using disjoint sets is O(E α(N)), where E is the number of edges and N is the number of vertices in the graph. The α function is the inverse Ackermann function. The find and union operations on disjoint sets take almost constant time (amortized O(α(n))), making this approach efficient even for large graphs.

Advanced Topics in Disjoint

The Ackermann Function and Its Relationship with Disjoint Sets

The Ackermann function is a classic example of a function that grows faster than any computable function, even more rapidly than exponential functions. As such, it demonstrates the theoretical limitations of computation and algorithms. Interestingly, the Ackermann function has a direct relationship to disjoint sets and their operations.

Specifically, it can be used to prove that the time complexity of certain disjoint set operations, like union and find with path compression, is log(n) amortized. The proof is based on analyzing the number of times any given element can be compressed when path compression is used after each find operation.

It turns out that for any particular element in a disjoint set with n elements, its parent pointer can only be changed at most log(n) times during all find operations performed on the set. This insight results in an upper bound for the time complexity of these operations within an amortized framework.

Dynamic Connectivity Problem: Offline vs Online

The dynamic connectivity problem involves maintaining connections between elements over time as new connections are added or deleted dynamically. There are two main versions of this problem: offline and online.

In the offline version, all connections are known ahead of time and must be processed together, often using Kruskal’s algorithm or other similar techniques. In contrast, online dynamic connectivity involves processing connections one at a time as they occur in real-time.

This version requires more complex algorithms to efficiently maintain all existing connections while processing new ones quickly. Disjoint sets offer an elegant solution to both versions by providing efficient methods for determining which elements are connected while minimizing unnecessary computations.


Disjoint sets provide a powerful tool for solving many problems involving connectivity in computer science. Using basic concepts like make-set, union-find and path compression it becomes easy to solve Kruskal’s algorithm for Minimum Spanning Tree problem and count connected components in graphs.

Moreover, using advanced topics such as the Ackermann function and online vs offline dynamic connectivity problem, we can understand the limitations of computation and devise more efficient algorithms. Despite their theoretical elegance, disjoint sets have concrete practical applications that are essential to modern computer science.

From computer networks to databases to artificial intelligence and beyond, the power of disjoint sets continues to drive innovation and progress. Understanding these concepts is a valuable asset for any aspiring computer scientist or engineer who strives to tackle complex problems with creativity and efficiency.

Related Articles