feature: kruskal algo logic added

Author: Debashis08

Headers/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h

@@ -2,6 +2,7 @@
 
 #include<map>
 #include<vector>
+#include<list>
 using namespace std;
 
 namespace MinimumSpanningTreeKruskalAlgorithm
@@ -22,22 +23,25 @@ namespace MinimumSpanningTreeKruskalAlgorithm
 		Node* nodeV;
 		int weight;
 		Edge(Node* nodeU, Node* nodeV, int weight);
-		bool CompareEdges(Edge* edgeX, Edge* edgeY);
 	};
 
 	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);
+		void PushUndirectedEdge(int valueU, int valueV, int weight);
 		void FindMinimumSpanningTreeKruskalAlgorithm();
+		vector<pair<pair<int, int>, int>> GetMinimumSpanningTree();
+		vector<Edge*> GetSortedEdgeList();
 	};
 }

SourceCodes/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.cc

@@ -1,5 +1,6 @@
 #include "../Headers/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h"
 #include<climits>
+#include<algorithm>
 using namespace std;
 
 namespace MinimumSpanningTreeKruskalAlgorithm
@@ -17,11 +18,6 @@ namespace MinimumSpanningTreeKruskalAlgorithm
 		this->nodeV = nodeV;
 		this->weight = weight;
 	}
-	
-	bool Edge::CompareEdges(Edge* edgeX, Edge* edgeY)
-	{
-		return (edgeX->weight < edgeY->weight);
-	}
 
 	// Graph Private Member Methods
 	Node* Graph::MakeOrFindNode(int data)
@@ -76,12 +72,41 @@ namespace MinimumSpanningTreeKruskalAlgorithm
 	}
 
 	// Graph Public Member Methods
-	void Graph::PushUndirectedEdge(int dataU, int dataV)
+	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;
+	}
+
+	vector<Edge*> Graph::GetSortedEdgeList()
+	{
+		return this->_edgeList;
 	}
 }

Tests/0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithmTest.cc

@@ -0,0 +1,30 @@
+#include<gtest/gtest.h>
+#include<0003_Graph/0007_MinimumSpanningTreeKruskalAlgorithm.h>
+
+namespace MinimumSpanningTreeKruskalAlgorithm
+{
+	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();
+
+		auto res1 = graph.GetSortedEdgeList();
+		auto res2 = graph.GetMinimumSpanningTree();
+	}
+}