diff --git a/DIRECTORY.md b/DIRECTORY.md
index e8b2604d0..7c2e6956b 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -46,6 +46,8 @@
     * [Main Cll](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/cll/main_cll.cpp)
   * [Disjoint Set](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/disjoint_set.cpp)
   * [Doubly Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/doubly_linked_list.cpp)
+  * [Dsu Path Compression](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/dsu_path_compression.cpp)
+  * [Dsu Union Rank](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/dsu_union_rank.cpp)
   * [Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/linked_list.cpp)
   * [Linkedlist Implentation Usingarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/linkedlist_implentation_usingarray.cpp)
   * [List Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/list_array.cpp)
diff --git a/data_structures/dsu_path_compression.cpp b/data_structures/dsu_path_compression.cpp
new file mode 100644
index 000000000..a5c0aec33
--- /dev/null
+++ b/data_structures/dsu_path_compression.cpp
@@ -0,0 +1,213 @@
+/**
+ * @file
+ * @brief [DSU (Disjoint
+ * sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
+ * @details
+ * It is a very powerful data structure that keeps track of different
+ * clusters(sets) of elements, these sets are disjoint(doesnot have a common
+ * element). Disjoint sets uses cases : for finding connected components in a
+ * graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
+ * Operations that can be performed:
+ * 1) UnionSet(i,j): add(element i and j to the set)
+ * 2) findSet(i): returns the representative of the set to which i belogngs to.
+ * 3) get_max(i),get_min(i) : returns the maximum and minimum
+ * Below is the class-based approach which uses the heuristic of path
+ * compression. Using path compression in findSet(i),we are able to get to the
+ * representative of i in O(1) time.
+ * @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
+ * @see dsu_union_rank.cpp
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
+
+using std::cout;
+using std::endl;
+using std::vector;
+
+/**
+ * @brief Disjoint sets union data structure, class based representation.
+ * @param n number of elements
+ */
+class dsu {
+ private:
+    vector<uint64_t> p;           ///< keeps track of the parent of ith element
+    vector<uint64_t> depth;       ///< tracks the depth(rank) of i in the tree
+    vector<uint64_t> setSize;     ///< size of each chunk(set)
+    vector<uint64_t> maxElement;  ///< maximum of each set to which i belongs to
+    vector<uint64_t> minElement;  ///< minimum of each set to which i belongs to
+ public:
+    /**
+     * @brief contructor for initialising all data members.
+     * @param n number of elements
+     */
+    explicit dsu(uint64_t n) {
+        p.assign(n, 0);
+        /// initially, all of them are their own parents
+        for (uint64_t i = 0; i < n; i++) {
+            p[i] = i;
+        }
+        /// initially all have depth are equals to zero
+        depth.assign(n, 0);
+        maxElement.assign(n, 0);
+        minElement.assign(n, 0);
+        for (uint64_t i = 0; i < n; i++) {
+            depth[i] = 0;
+            maxElement[i] = i;
+            minElement[i] = i;
+        }
+        setSize.assign(n, 0);
+        /// initially set size will be equals to one
+        for (uint64_t i = 0; i < n; i++) {
+            setSize[i] = 1;
+        }
+    }
+
+    /**
+     * @brief Method to find the representative of the set to which i belongs
+     * to, T(n) = O(1)
+     * @param i element of some set
+     * @returns representative of the set to which i belongs to.
+     */
+    uint64_t findSet(uint64_t i) {
+        /// using path compression
+        if (p[i] == i) {
+            return i;
+        }
+        return (p[i] = findSet(p[i]));
+    }
+    /**
+     * @brief Method that combines two disjoint sets to which i and j belongs to
+     * and make a single set having a common representative.
+     * @param i element of some set
+     * @param j element of some set
+     * @returns void
+     */
+    void UnionSet(uint64_t i, uint64_t j) {
+        /// check if both belongs to the same set or not
+        if (isSame(i, j)) {
+            return;
+        }
+
+        // we find the representative of the i and j
+        uint64_t x = findSet(i);
+        uint64_t y = findSet(j);
+
+        /// always keeping the min as x
+        /// shallow tree
+        if (depth[x] > depth[y]) {
+            std::swap(x, y);
+        }
+        /// making the shallower root's parent the deeper root
+        p[x] = y;
+
+        /// if same depth, then increase one's depth
+        if (depth[x] == depth[y]) {
+            depth[y]++;
+        }
+        /// total size of the resultant set
+        setSize[y] += setSize[x];
+        /// changing the maximum elements
+        maxElement[y] = std::max(maxElement[x], maxElement[y]);
+        minElement[y] = std::min(minElement[x], minElement[y]);
+    }
+    /**
+     * @brief A utility function which check whether i and j belongs to
+     * same set or not
+     * @param i element of some set
+     * @param j element of some set
+     * @returns `true` if element `i` and `j` ARE in the same set
+     * @returns `false` if element `i` and `j` are NOT in same set
+     */
+    bool isSame(uint64_t i, uint64_t j) {
+        if (findSet(i) == findSet(j)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @brief prints the minimum, maximum and size of the set to which i belongs
+     * to
+     * @param i element of some set
+     * @returns void
+     */
+    vector<uint64_t> get(uint64_t i) {
+        vector<uint64_t> ans;
+        ans.push_back(get_min(i));
+        ans.push_back(get_max(i));
+        ans.push_back(size(i));
+        return ans;
+    }
+    /**
+     * @brief A utility function that returns the size of the set to which i
+     * belongs to
+     * @param i element of some set
+     * @returns size of the set to which i belongs to
+     */
+    uint64_t size(uint64_t i) { return setSize[findSet(i)]; }
+    /**
+     * @brief A utility function that returns the max element of the set to
+     * which i belongs to
+     * @param i element of some set
+     * @returns maximum of the set to which i belongs to
+     */
+    uint64_t get_max(uint64_t i) { return maxElement[findSet(i)]; }
+    /**
+     * @brief A utility function that returns the min element of the set to
+     * which i belongs to
+     * @param i element of some set
+     * @returns minimum of the set to which i belongs to
+     */
+    uint64_t get_min(uint64_t i) { return minElement[findSet(i)]; }
+};
+
+/**
+ * @brief Self-test implementations, 1st test
+ * @returns void
+ */
+static void test1() {
+    // the minimum, maximum, and size of the set
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+    // set 1
+    d.UnionSet(1, 2);  // performs union operation on 1 and 2
+    d.UnionSet(1, 4);  // performs union operation on 1 and 4
+    vector<uint64_t> ans = {1, 4, 3};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.get(4).at(i) == ans[i]);  // makes sure algorithm works fine
+    }
+    cout << "1st test passed!" << endl;
+}
+/**
+ * @brief Self-implementations, 2nd test
+ * @returns void
+ */
+static void test2() {
+    // the minimum, maximum, and size of the set 
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+    // set 1
+    d.UnionSet(3, 5);
+    d.UnionSet(5, 6);
+    d.UnionSet(5, 7);
+    vector<uint64_t> ans = {3, 7, 4};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.get(3).at(i) == ans[i]);  // makes sure algorithm works fine
+    }
+    cout << "2nd test passed!" << endl;
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ * */
+int main() {
+    uint64_t n = 10;  ///< number of items
+    dsu d(n + 1);     ///< object of class disjoint sets
+
+    test1();  // run 1st test case
+    test2();  // run 2nd test case
+
+    return 0;
+}
diff --git a/data_structures/dsu_union_rank.cpp b/data_structures/dsu_union_rank.cpp
new file mode 100644
index 000000000..8936d6d69
--- /dev/null
+++ b/data_structures/dsu_union_rank.cpp
@@ -0,0 +1,187 @@
+/**
+ * @file
+ * @brief [DSU (Disjoint
+ * sets)](https://en.wikipedia.org/wiki/Disjoint-set-data_structure)
+ * @details
+ * dsu : It is a very powerful data structure which keeps track of different
+ * clusters(sets) of elements, these sets are disjoint(doesnot have a common
+ * element). Disjoint sets uses cases : for finding connected components in a
+ * graph, used in Kruskal's algorithm for finding Minimum Spanning tree.
+ * Operations that can be performed:
+ * 1) UnionSet(i,j): add(element i and j to the set)
+ * 2) findSet(i): returns the representative of the set to which i belogngs to.
+ * 3) getParents(i): prints the parent of i and so on and so forth.
+ * Below is the class-based approach which uses the heuristic of union-ranks.
+ * Using union-rank in findSet(i),we are able to get to the representative of i
+ * in slightly delayed O(logN) time but it allows us to keep tracks of the
+ * parent of i.
+ * @author [AayushVyasKIIT](https://github.com/AayushVyasKIIT)
+ * @see dsu_path_compression.cpp
+ */
+
+#include <cassert>   /// for assert
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
+
+using std::cout;
+using std::endl;
+using std::vector;
+
+/**
+ * @brief Disjoint sets union data structure, class based representation.
+ * @param n number of elements
+ */
+class dsu {
+ private:
+    vector<uint64_t> p;        ///< keeps track of the parent of ith element
+    vector<uint64_t> depth;    ///< tracks the depth(rank) of i in the tree
+    vector<uint64_t> setSize;  ///< size of each chunk(set)
+ public:
+    /**
+     * @brief constructor for initialising all data members
+     * @param n number of elements
+     */
+    explicit dsu(uint64_t n) {
+        p.assign(n, 0);
+        /// initially all of them are their own parents
+        depth.assign(n, 0);
+        setSize.assign(n, 0);
+        for (uint64_t i = 0; i < n; i++) {
+            p[i] = i;
+            depth[i] = 0;
+            setSize[i] = 1;
+        }
+    }
+    /**
+     * @brief Method to find the representative of the set to which i belongs
+     * to, T(n) = O(logN)
+     * @param i element of some set
+     * @returns representative of the set to which i belongs to
+     */
+    uint64_t findSet(uint64_t i) {
+        /// using union-rank
+        while (i != p[i]) {
+            i = p[i];
+        }
+        return i;
+    }
+    /**
+     * @brief Method that combines two disjoint sets to which i and j belongs to
+     * and make a single set having a common representative.
+     * @param i element of some set
+     * @param j element of some set
+     * @returns void
+     */
+    void unionSet(uint64_t i, uint64_t j) {
+        /// checks if both belongs to same set or not
+        if (isSame(i, j)) {
+            return;
+        }
+        /// we find representative of the i and j
+        uint64_t x = findSet(i);
+        uint64_t y = findSet(j);
+
+        /// always keeping the min as x
+        /// in order to create a shallow tree
+        if (depth[x] > depth[y]) {
+            std::swap(x, y);
+        }
+        /// making the shallower tree, root parent of the deeper root
+        p[x] = y;
+
+        /// if same depth, then increase one's depth
+        if (depth[x] == depth[y]) {
+            depth[y]++;
+        }
+        /// total size of the resultant set
+        setSize[y] += setSize[x];
+    }
+    /**
+     * @brief A utility function which check whether i and j belongs to same set
+     * or not
+     * @param i element of some set
+     * @param j element of some set
+     * @returns `true` if element i and j are in same set
+     * @returns `false` if element i and j are not in same set
+     */
+    bool isSame(uint64_t i, uint64_t j) {
+        if (findSet(i) == findSet(j)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @brief Method to print all the parents of i, or the path from i to
+     * representative.
+     * @param i element of some set
+     * @returns void
+     */
+    vector<uint64_t> getParents(uint64_t i) {
+        vector<uint64_t> ans;
+        while (p[i] != i) {
+            ans.push_back(i);
+            i = p[i];
+        }
+        ans.push_back(i);
+        return ans;
+    }
+};
+/**
+ * @brief Self-implementations, 1st test
+ * @returns void
+ */
+static void test1() {
+    /* checks the parents in the resultant structures */
+    uint64_t n = 10;   ///< number of elements
+    dsu d(n + 1);      ///< object of class disjoint sets
+    d.unionSet(2, 1);  ///< performs union operation on 1 and 2
+    d.unionSet(1, 4);
+    d.unionSet(8, 1);
+    d.unionSet(3, 5);
+    d.unionSet(5, 6);
+    d.unionSet(5, 7);
+    d.unionSet(9, 10);
+    d.unionSet(2, 10);
+    // keeping track of the changes using parent pointers
+    vector<uint64_t> ans = {7, 5};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.getParents(7).at(i) ==
+               ans[i]);  // makes sure algorithm works fine
+    }
+    cout << "1st test passed!" << endl;
+}
+/**
+ * @brief Self-implementations, 2nd test
+ * @returns void
+ */
+static void test2() {
+    // checks the parents in the resultant structures
+    uint64_t n = 10;   ///< number of elements
+    dsu d(n + 1);      ///< object of class disjoint sets
+    d.unionSet(2, 1);  /// performs union operation on 1 and 2
+    d.unionSet(1, 4);
+    d.unionSet(8, 1);
+    d.unionSet(3, 5);
+    d.unionSet(5, 6);
+    d.unionSet(5, 7);
+    d.unionSet(9, 10);
+    d.unionSet(2, 10);
+
+    /// keeping track of the changes using parent pointers
+    vector<uint64_t> ans = {2, 1, 10};
+    for (uint64_t i = 0; i < ans.size(); i++) {
+        assert(d.getParents(2).at(i) ==
+               ans[i]);  /// makes sure algorithm works fine
+    }
+    cout << "2nd test passed!" << endl;
+}
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test1();  // run 1st test case
+    test2();  // run 2nd test case
+
+    return 0;
+}