Feature graph implementation

Headers/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include<map>
+#include<vector>
+#include<list>
+using namespace std;
+
+namespace MinimumSpanningTreeKruskalAlgorithm
+{
+	class Node
+	{
+	public:
+		int data;
+		Node* parent;
+		int rank;
+		Node(int data);
+	};
+
+	class Edge
+	{
+	public:
+		Node* nodeU;
+		Node* nodeV;
+		int weight;
+		Edge(Node* nodeU, Node* nodeV, int weight);
+	};
+
+	class Graph
+	{
+	private:
+		map<Node*, vector<Node*>> _adjlist;
+		map<int, Node*> _nodeMap;
+		vector<Edge*> _edgeList;
+		vector<pair<pair<int, int>, int>> _minimumSpanningTree;
+		Node* MakeOrFindNode(int data);
+		void MakeSet(Node* node);
+		void Union(Node* nodeU, Node* nodeV);
+		void Link(Node* nodeU, Node* nodeV);
+		Node* FindSet(Node* node);
+
+	public:
+		void PushUndirectedEdge(int valueU, int valueV, int weight);
+		void FindMinimumSpanningTreeKruskalAlgorithm();
+		vector<pair<pair<int, int>, int>> GetMinimumSpanningTree();
+	};
+}

SourceCodes/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.cc

@@ -0,0 +1,107 @@
+#include "../Headers/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h"
+#include<climits>
+#include<algorithm>
+using namespace std;
+
+namespace MinimumSpanningTreeKruskalAlgorithm
+{
+	Node::Node(int data)
+	{
+		this->data = data;
+		this->parent = nullptr;
+		this->rank = INT_MAX;
+	}
+
+	Edge::Edge(Node* nodeU, Node* nodeV, int weight)
+	{
+		this->nodeU = nodeU;
+		this->nodeV = nodeV;
+		this->weight = weight;
+	}
+
+	// Graph Private Member Methods
+	Node* Graph::MakeOrFindNode(int data)
+	{
+		Node* node = nullptr;
+		if (this->_nodeMap.find(data) == this->_nodeMap.end())
+		{
+			node = new Node(data);
+			this->_nodeMap[data] = node;
+		}
+		else
+		{
+			node = this->_nodeMap[data];
+		}
+		return node;
+	}
+
+	void Graph::MakeSet(Node* node)
+	{
+		node->parent = node;
+		node->rank = 0;
+	}
+
+	void Graph::Union(Node* nodeU, Node* nodeV)
+	{
+		this->Link(this->FindSet(nodeU), this->FindSet(nodeV));
+	}
+
+	void Graph::Link(Node* nodeU, Node* nodeV)
+	{
+		if (nodeV->rank > nodeU->rank)
+		{
+			nodeU->parent = nodeV;
+		}
+		else
+		{
+			nodeV->parent = nodeU;
+			if (nodeU->rank == nodeV->rank)
+			{
+				nodeU->rank += 1;
+			}
+		}
+	}
+
+	Node* Graph::FindSet(Node* node)
+	{
+		if (node != node->parent)
+		{
+			node->parent = this->FindSet(node->parent);
+		}
+		return node->parent;
+	}
+
+	// Graph Public Member Methods
+	void Graph::PushUndirectedEdge(int dataU, int dataV, int weight)
+	{
+		Node* nodeU = this->MakeOrFindNode(dataU);
+		Node* nodeV = this->MakeOrFindNode(dataV);
+
+		this->_adjlist[nodeU].push_back(nodeV);
+		this->_adjlist[nodeV].push_back(nodeU);
+		this->_edgeList.push_back(new Edge(nodeU, nodeV, weight));
+	}
+	void Graph::FindMinimumSpanningTreeKruskalAlgorithm()
+	{
+		for (auto iterator : this->_nodeMap)
+		{
+			this->MakeSet(iterator.second);
+		}
+
+		sort(this->_edgeList.begin(), this->_edgeList.end(), [](Edge* edgeX, Edge* edgeY) { return edgeX->weight < edgeY->weight; });
+
+		for (auto edge : this->_edgeList)
+		{
+			if (this->FindSet(edge->nodeU) != this->FindSet(edge->nodeV))
+			{
+				this->Union(edge->nodeU, edge->nodeV);
+				this->_minimumSpanningTree.push_back({ {edge->nodeU->data, edge->nodeV->data}, edge->weight });
+			}
+		}
+	}
+
+	vector<pair<pair<int, int>, int>> Graph::GetMinimumSpanningTree()
+	{
+		return this->_minimumSpanningTree;
+	}
+}

SourceCodes/0003_Graph/CMakeLists.txt

@@ -6,6 +6,8 @@ set(0003GRAPH_SOURCES
     0004_StronglyConnectedComponents.cc
     0005_HamiltonianPathAndCycle.cc
     0006_EulerianPathAndCircuit.cc
+    0007_MinimumSpanningTreeKruskalAlgorithm.cc
+
 )
 
 # Create a library target

Tests/0000_CommonUtilities/UnitTestHelper.h

@@ -136,4 +136,22 @@ class UnitTestHelper
 		reverse(normalizedCycle2.begin() + 1, normalizedCycle2.end());
 		return (normalizedCycle1 == normalizedCycle2);
 	}
+
+	template<typename T>
+	vector<pair<pair<T, T>, T>> SortVectorOfPair(vector<pair<pair<T, T>, T>> data)
+	{
+		for (auto& iterator : data)
+		{
+			if (iterator.first.first > iterator.first.second)
+			{
+				swap(iterator.first.first, iterator.first.second);
+			}
+		}
+
+		sort(data.begin(), data.end(), [](const pair<pair<T, T>, T>& pairA, const pair<pair<T, T>, T>& pairB)
+			{
+				return pairA.second < pairB.second;
+			});
+		return data;
+	}
 };

Tests/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithmTest.cc

@@ -0,0 +1,45 @@
+#include<gtest/gtest.h>
+#include "../Headers/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h"
+#include "../0000_CommonUtilities/UnitTestHelper.h"
+
+namespace MinimumSpanningTreeKruskalAlgorithm
+{
+	UnitTestHelper unitTestHelper;
+
+	TEST(MST, Kruskal)
+	{
+		Graph graph;
+
+		graph.PushUndirectedEdge(1, 2, 4);
+		graph.PushUndirectedEdge(1, 8, 8);
+		graph.PushUndirectedEdge(2, 8, 11);
+		graph.PushUndirectedEdge(2, 3, 8);
+		graph.PushUndirectedEdge(3, 4, 7);
+		graph.PushUndirectedEdge(3, 9, 2);
+		graph.PushUndirectedEdge(3, 6, 4);
+		graph.PushUndirectedEdge(4, 5, 9);
+		graph.PushUndirectedEdge(4, 6, 14);
+		graph.PushUndirectedEdge(5, 6, 10);
+		graph.PushUndirectedEdge(6, 7, 2);
+		graph.PushUndirectedEdge(7, 8, 1);
+		graph.PushUndirectedEdge(7, 9, 6);
+		graph.PushUndirectedEdge(8, 9, 7);
+
+		graph.FindMinimumSpanningTreeKruskalAlgorithm();
+
+		vector<pair<pair<int,int>, int>> actualMST = graph.GetMinimumSpanningTree();
+		vector<pair<pair<int, int>, int>> expectedMST =
+		{
+			{{7, 8}, 1},
+			{{3, 9}, 2},
+			{{6, 7}, 2},
+			{{2, 1}, 4},
+			{{3, 6}, 4},
+			{{3, 4}, 7},
+			{{8, 1}, 8},
+			{{4, 5}, 9}
+		};
+
+		ASSERT_EQ(unitTestHelper.SortVectorOfPair(actualMST), unitTestHelper.SortVectorOfPair(expectedMST));
+	}
+}

Tests/0003_Graph/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(
   0004_StronglyConnectedComponentsTest.cc
   0005_HamiltonianPathAndCycleTest.cc
   0006_EulerianPathAndCircuitTest.cc
+  0007_MinimumSpanningTreeKruskalAlgorithmTest.cc
 )
 
 target_link_libraries(