Union-Find Data Structure (#113)

* subset struct for union-find

* set union find operations

* basic tests for union-find data structure

Author: sidml

.gitignore

@@ -30,3 +30,6 @@
 *.exe
 *.out
 *.app
+
+# ignore the build folder contents from git
+build/

CMakeLists.txt

@@ -60,6 +60,7 @@ add_executable(test_exe test/main.cpp
 						test/PartitionTest.cpp
 						test/DialTest.cpp
 						test/GraphSlicingTest.cpp
+						test/UnionFindTest.cpp
 				)
 target_include_directories(test_exe PUBLIC
 						  "${PROJECT_SOURCE_DIR}/include"

include/Graph/Graph.hpp

@@ -153,6 +153,25 @@ namespace CXXGRAPH
 		*/
 		virtual const AdjacencyMatrix<T> getAdjMatrix() const;
 		/**
+		* @brief This function finds the subset of given a nodeId
+		* @param subset query subset, we want to find target in this subset
+		* @param elem elem that we wish to find in the subset
+ 		*
+ 		* @return parent node of elem 
+		* Note: No Thread Safe
+		*/
+		virtual const unsigned long setFind(Subset subsets [], const unsigned long elem) const;
+		/**
+		* @brief This function modifies the original subset array
+		* such that it the union of two sets a and b
+		* @param subset query subset, we want to find target in this subset
+		* @param a parent id of set1
+		* @param b parent id of set2
+ 		*
+		* Note: No Thread Safe
+		*/
+		virtual void setUnion(Subset subsets [], const unsigned long set1, const unsigned long elem2) const;		
+		/**
  		* @brief Function runs the dijkstra algorithm for some source node and
  		* target node in the graph and returns the shortest distance of target
  		* from the source.
@@ -864,6 +883,39 @@ namespace CXXGRAPH
 		return 0;
 	}
 
+	template <typename T>
+	const unsigned long Graph<T>::setFind(Subset subsets [], const unsigned long nodeId) const
+	{
+		// find root and make root as parent of i
+		// (path compression)
+		if (subsets[nodeId].parent != nodeId)
+		{
+			subsets[nodeId].parent = Graph<T>::setFind(subsets, subsets[nodeId].parent);
+		}
+		
+		return subsets[nodeId].parent;
+	}
+
+	template <typename T>
+	void Graph<T>::setUnion(Subset subsets [], const unsigned long elem1, const unsigned long elem2) const
+	{
+		// if both sets have same parent
+		// then there's nothing to be done
+		if (subsets[elem1].parent==subsets[elem2].parent)
+			return;
+		auto elem1Parent = Graph<T>::setFind(subsets, elem1);
+		auto elem2Parent = Graph<T>::setFind(subsets, elem2);
+		if(subsets[elem1Parent].rank < subsets[elem2Parent].rank) 
+			subsets[elem1Parent].parent = elem2Parent;
+		else if(subsets[elem1Parent].rank > subsets[elem2Parent].rank) 
+			subsets[elem2Parent].parent = elem1Parent;
+		else
+		{
+			subsets[elem2Parent].parent = elem1Parent;
+			subsets[elem1Parent].rank++;
+		}	
+	}
+	
 	template <typename T>
 	const AdjacencyMatrix<T> Graph<T>::getAdjMatrix() const
 	{

include/Utility/Typedef.hpp

@@ -56,7 +56,15 @@ namespace CXXGRAPH
 
     /////////////////////////////////////////////////////
     // Structures ///////////////////////////////////////
-    
+
+    /// Struct useful for union-find operations
+	struct Subset_struct
+	{
+		unsigned long parent;		   // parent of the current set
+		unsigned long rank; 		  // rank of the current set, used for balancing the trees
+	};
+	typedef Subset_struct Subset;
+
     /// Struct that contains the information about Dijsktra's Algorithm results
 	struct DijkstraResult_struct
 	{

test/UnionFindTest.cpp

@@ -0,0 +1,54 @@
+#include "gtest/gtest.h"
+#include "CXXGraph.hpp"
+
+TEST(UnionFindTest, test_1)
+{
+    CXXGRAPH::Node<int> node0(0, 0);
+    CXXGRAPH::Node<int> node1(1, 1);
+    CXXGRAPH::Node<int> node2(2, 2);
+    CXXGRAPH::Node<int> node3(3, 3);
+
+    /*
+            0
+           1 2
+          3
+    */
+    CXXGRAPH::UndirectedWeightedEdge<int> edge1(0, node0, node1, 5);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge2(1, node0, node2, 10);
+    CXXGRAPH::UndirectedWeightedEdge<int> edge3(2, node1, node3, 5);
+
+    std::list<const CXXGRAPH::Edge<int> *> edgeSet;
+    edgeSet.push_back(&edge1);
+
+    CXXGRAPH::Graph<int> graph(edgeSet);
+
+    // every element is a subset of itself
+    CXXGRAPH::Subset subset[4] = {{0, 0}, {1, 0}, {2, 0}, {3, 0}};
+    auto res = graph.setFind(subset, node0.getId());
+    ASSERT_EQ(res, 0);
+    res = graph.setFind(subset, node1.getId());
+    ASSERT_EQ(res, 1);
+    res = graph.setFind(subset, node2.getId());
+    ASSERT_EQ(res, 2);
+
+    // element 1 & 2 are subset of 0
+    // element 3 is subset of 1
+    CXXGRAPH::Subset subset1[4] = {{0, 0}, {0, 0}, {0, 0}, {1, 0}};
+    auto res1 = graph.setFind(subset1, node0.getId());
+    ASSERT_EQ(res1, 0);
+    res = graph.setFind(subset1, node3.getId());
+    ASSERT_EQ(res1, 0);
+    res = graph.setFind(subset1, node2.getId());
+    ASSERT_EQ(res1, 0);
+
+    // union of (node 1 & node3)  should increase node0 rank by 1
+    CXXGRAPH::Subset subset2[4] = {{0, 0}, {0, 0}, {0, 0}, {1, 0}};
+    graph.setUnion(subset2, node1.getId(), node3.getId());
+    ASSERT_EQ(subset2[0].rank, 1);
+    ASSERT_EQ(subset2[3].parent, 0);
+
+    // rank shouldn't increase since both have the same parent
+    graph.setUnion(subset2, node2.getId(), node3.getId());
+    ASSERT_EQ(subset2[0].rank, 1);
+    ASSERT_EQ(subset2[3].parent, 0);
+}