Merge pull request #15 from Debashis08/feature-graph-implementation

Debashis08 · web-flow · commit 64252c7868ec · 2024-10-08T01:05:49.000+05:30
Feature graph implementation
diff --git a/Headers/0003_Graph/0001_BreadthFirstSearch.h b/Headers/0003_Graph/0001_BreadthFirstSearch.h
@@ -2,29 +2,31 @@
 
 #include<list>
 #include<map>
+#include<utility>
 #include<string>
+#include<vector>
 using namespace std;
 enum color { WHITE, GRAY, BLACK };
 
-class Node
+class BFSNode
 {
 public:
     char data;
     int distance;
     int color;
-    Node* parent;
-    Node(char value);
+    BFSNode* parent;
+    BFSNode(char value);
 };
 
 class BFSGraph
 {
 private:
-    map<Node*, list<Node*>> _adjlist;
-    map<char, Node*> _nodeMap;
-    Node* MakeOrFindNode(char value);
-    void BreadthFirstSearch(Node* node);
+    map<BFSNode*, list<BFSNode*>> _adjlist;
+    map<char, BFSNode*> _nodeMap;
+    BFSNode* MakeOrFindNode(char value);
+    void BreadthFirstSearch(BFSNode* node);
 public:
     void PushUndirectedEdge(char valueU, char valueV);
     void BFS(char value);
-    string ShowBFSResult();
+    vector<pair<char, int>> ShowBFSResult();
 };
diff --git a/Headers/0003_Graph/0002_DepthFirstSearch.h b/Headers/0003_Graph/0002_DepthFirstSearch.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include<list>
+#include<map>
+#include<string>
+#include<vector>
+using namespace std;
+enum color { WHITE, GRAY, BLACK };
+
+class DFSNode
+{
+public:
+    char data;
+    int color;
+    int discoveredTime;
+    int finishingTime;
+    DFSNode* parent;
+    DFSNode(char value);
+};
+
+class DFSGraph
+{
+private:
+    int time;
+    map<DFSNode*, list<DFSNode*>> _adjlist;
+    map<char, DFSNode*> _nodeMap;
+    DFSNode* MakeOrFindNode(char value);
+    void DepthFirstSearch(DFSNode* DFSNode);
+public:
+    void PushDirectedEdge(char valueU, char valueV);
+    void DFS();
+    vector<pair<char,pair<int,int>>> ShowDFSResult();
+};
diff --git a/SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc b/SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc
@@ -1,24 +1,26 @@
 #include "../Headers/0003_Graph/0001_BreadthFirstSearch.h"
 #include<iostream>
 #include<queue>
+#include<vector>
+#include<utility>
 #include<string>
 #include<climits>
 using namespace std;
 
-Node::Node(char value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
+BFSNode::BFSNode(char value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
 {
 	this->data = value;
-	distance = INT_MAX;
-	color = WHITE;
-	parent = NULL;
+	this->distance = INT_MAX;
+	this->color = WHITE;
+	this->parent = nullptr;
 }
 
-Node* BFSGraph::MakeOrFindNode(char value)
+BFSNode* BFSGraph::MakeOrFindNode(char value)
 {
-	Node* node = NULL;
+	BFSNode* node = nullptr;
 	if (this->_nodeMap.find(value) == this->_nodeMap.end())
 	{
-		node = new Node(value);
+		node = new BFSNode(value);
 		this->_nodeMap[value] = node;
 	}
 	else
@@ -28,21 +30,21 @@ Node* BFSGraph::MakeOrFindNode(char value)
 	return node;
 }
 
-void BFSGraph::BreadthFirstSearch(Node* node)
+void BFSGraph::BreadthFirstSearch(BFSNode* node)
 {
 	node->color = WHITE;
 	node->distance = 0;
-	node->parent = NULL;
+	node->parent = nullptr;
 
-	queue<Node*> nodeQueue;
+	queue<BFSNode*> nodeQueue;
 	nodeQueue.push(node);
 
 	while (nodeQueue.empty()!=true)
 	{
-		Node* currentNode = nodeQueue.front();
+		BFSNode* currentNode = nodeQueue.front();
 		nodeQueue.pop();
 
-		for (auto adjacentNode : this->_adjlist[currentNode])
+		for (auto &adjacentNode : this->_adjlist[currentNode])
 		{
 			if (adjacentNode->color == WHITE)
 			{
@@ -58,8 +60,8 @@ void BFSGraph::BreadthFirstSearch(Node* node)
 
 void BFSGraph::PushUndirectedEdge(char valueU, char valueV)
 {
-	Node* nodeU = this->MakeOrFindNode(valueU);
-	Node* nodeV = this->MakeOrFindNode(valueV);
+	BFSNode* nodeU = this->MakeOrFindNode(valueU);
+	BFSNode* nodeV = this->MakeOrFindNode(valueV);
 
 	this->_adjlist[nodeU].push_back(nodeV);
 	this->_adjlist[nodeV].push_back(nodeU);
@@ -70,12 +72,12 @@ void BFSGraph::BFS(char value)
 	this->BreadthFirstSearch(this->_nodeMap[value]);
 }
 
-string BFSGraph::ShowBFSResult()
+vector<pair<char, int>> BFSGraph::ShowBFSResult()
 {
-	string result = "";
-	for (auto value : this->_nodeMap)
+	vector<pair<char, int>> result;
+	for (auto& node : this->_nodeMap)
 	{
-		result = result + " " + value.first + "(" + to_string(value.second->distance) + ")";
+		result.push_back(make_pair(node.first, node.second->distance));
 	}
 	return result;
 }
diff --git a/SourceCodes/0003_Graph/0002_DepthFirstSearch.cc b/SourceCodes/0003_Graph/0002_DepthFirstSearch.cc
@@ -0,0 +1,76 @@
+#include "../Headers/0003_Graph/0002_DepthFirstSearch.h"
+#include<vector>
+#include<utility>
+#include<climits>
+using namespace std;
+
+DFSNode::DFSNode(char value)
+{
+	this->data = value;
+	this->discoveredTime = INT_MAX;
+	this->finishingTime = INT_MAX;
+	this->color = WHITE;
+	this->parent = nullptr;
+}
+
+DFSNode* DFSGraph::MakeOrFindNode(char value)
+{
+	DFSNode* node = nullptr;
+	if (this->_nodeMap.find(value) == this->_nodeMap.end())
+	{
+		node = new DFSNode(value);
+		this->_nodeMap[value] = node;
+	}
+	else
+	{
+		node = this->_nodeMap[value];
+	}
+	return node;
+}
+void DFSGraph::DepthFirstSearch(DFSNode* nodeU)
+{
+	this->time++;
+	nodeU->discoveredTime = this->time;
+	nodeU->color = GRAY;
+	for (auto nodeV : this->_adjlist[nodeU])
+	{
+		if (nodeV->color == WHITE)
+		{
+			nodeV->parent = nodeU;
+			this->DepthFirstSearch(nodeV);
+		}
+	}
+	nodeU->color = BLACK;
+	this->time++;
+	nodeU->finishingTime = time;
+}
+
+void DFSGraph::PushDirectedEdge(char valueU, char valueV)
+{
+	DFSNode* nodeU = this->MakeOrFindNode(valueU);
+	DFSNode* nodeV = this->MakeOrFindNode(valueV);
+
+	this->_adjlist[nodeU].push_back(nodeV);
+}
+
+void DFSGraph::DFS()
+{
+	this->time = 0;
+	for (auto& iterator:this->_nodeMap)
+	{
+		if (iterator.second->color == WHITE)
+		{
+			this->DepthFirstSearch(iterator.second);
+		}
+	}
+}
+
+vector<pair<char, pair<int, int>>> DFSGraph::ShowDFSResult()
+{
+	vector<pair<char, pair<int, int>>> result;
+	for (auto& node : this->_nodeMap)
+	{
+		result.push_back(make_pair(node.first, make_pair(node.second->discoveredTime, node.second->finishingTime)));
+	}
+	return result;
+}
diff --git a/SourceCodes/0003_Graph/CMakeLists.txt b/SourceCodes/0003_Graph/CMakeLists.txt
@@ -1,6 +1,7 @@
 # Specify the source files
 set(0003GRAPH_SOURCES
     0001_BreadthFirstSearch.cc
+    0002_DepthFirstSearch.cc
 )
 
 # Create a library target
diff --git a/Tests/0000_CommonUtilities/UnitTestHelper.h b/Tests/0000_CommonUtilities/UnitTestHelper.h
@@ -12,11 +12,11 @@ class UnitTestHelper
 	string VerifyVectorResult(vector<T> vector)
 	{
 		string result = "";
-		for (auto iterator : vector)
+		for (auto& iterator : vector)
 		{
 			result += to_string(iterator) + " ";
 		}
 		result.pop_back();
 		return result;
 	}
-};
+};
diff --git a/Tests/0000_CommonUtilities/UnitTestHelperVectorOfPair.h b/Tests/0000_CommonUtilities/UnitTestHelperVectorOfPair.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include<iostream>
+#include<vector>
+#include<utility>
+#include<string>
+using namespace std;
+
+template<typename T1, typename T2>
+class UnitTestHelperVectorOfPair
+{
+public:
+	string VerifyVectorOfPair(vector<pair<T1,T2>> vector)
+	{
+		string result = "";
+		for (auto& iterator : vector)
+		{
+			result += string(1, iterator.first) + "(" + to_string(iterator.second) + ")" + " ";
+		}
+
+		if (!result.empty())
+		{
+			result.pop_back();
+		}
+		return result;
+	}
+
+	string VerifyVectorOfPairOfTwo(vector<pair<T1, pair<T2, T2>>> vector)
+	{
+		string result = "";
+		for (auto& iterator : vector)
+		{
+			result += string(1, iterator.first) + "(" + to_string(iterator.second.first) + "," + to_string(iterator.second.second) + ")" + " ";
+		}
+
+		if (!result.empty())
+		{
+			result.pop_back();
+		}
+		return result;
+	}
+};
diff --git a/Tests/0003_Graph/0001_BreadthFirstSearchTest.cc b/Tests/0003_Graph/0001_BreadthFirstSearchTest.cc
@@ -1,11 +1,14 @@
 #include <gtest/gtest.h>
 #include<string>
 #include "../Headers/0003_Graph/0001_BreadthFirstSearch.h"
+#include "../0000_CommonUtilities/UnitTestHelperVectorOfPair.h"
 
-// Demonstrate some basic assertions.
 namespace BreadthFirstSearchTest
 {
-	TEST(BFSTesting, ShowBFSResultTest) {
+    UnitTestHelperVectorOfPair<char, int> unitTestHelperVectorOfPair;
+
+	TEST(BFSTesting, ShowBFSResultTest01) 
+    {
 		BFSGraph graph;
 
         graph.PushUndirectedEdge('s', 'r');
@@ -21,8 +24,21 @@ namespace BreadthFirstSearchTest
 
         graph.BFS('s');
         
-        string actualResult = graph.ShowBFSResult();
-        string expectedResult = " r(1) s(0) t(2) u(3) v(2) w(1) x(2) y(3)";
+        string actualResult = unitTestHelperVectorOfPair.VerifyVectorOfPair(graph.ShowBFSResult());
+        string expectedResult = "r(1) s(0) t(2) u(3) v(2) w(1) x(2) y(3)";
         EXPECT_EQ(actualResult, expectedResult);
 	}
+
+    TEST(BFSTesting, ShowBFSResultTest02) 
+    {
+        BFSGraph graph;
+
+        graph.PushUndirectedEdge('s', 'r');
+
+        graph.BFS('s');
+
+        string actualResult = unitTestHelperVectorOfPair.VerifyVectorOfPair(graph.ShowBFSResult());
+        string expectedResult = "r(1) s(0)";
+        EXPECT_EQ(actualResult, expectedResult);
+    }
 }
diff --git a/Tests/0003_Graph/0002_DepthFirstSearchTest.cc b/Tests/0003_Graph/0002_DepthFirstSearchTest.cc
@@ -0,0 +1,28 @@
+#include<gtest/gtest.h>
+#include "../Headers/0003_Graph/0002_DepthFirstSearch.h"
+#include "../0000_CommonUtilities/UnitTestHelperVectorOfPair.h"
+
+namespace DepthFirstSearchTest
+{
+    UnitTestHelperVectorOfPair<char, int> unitTestHelperVectorOfPair;
+
+    TEST(DFSTesting, ShowDFSResultTest01)
+    {
+        DFSGraph graph;
+
+        graph.PushDirectedEdge('u', 'v');
+        graph.PushDirectedEdge('u', 'x');
+        graph.PushDirectedEdge('v', 'y');
+        graph.PushDirectedEdge('w', 'y');
+        graph.PushDirectedEdge('w', 'z');
+        graph.PushDirectedEdge('x', 'v');
+        graph.PushDirectedEdge('y', 'x');
+        graph.PushDirectedEdge('z', 'z');
+
+        graph.DFS();
+
+        string actualResult = unitTestHelperVectorOfPair.VerifyVectorOfPairOfTwo(graph.ShowDFSResult());
+        string expectedResult = "u(1,8) v(2,7) w(9,12) x(4,5) y(3,6) z(10,11)";
+        EXPECT_EQ(actualResult, expectedResult);
+    }
+}
diff --git a/Tests/0003_Graph/CMakeLists.txt b/Tests/0003_Graph/CMakeLists.txt

Original file line number	Diff line number	Diff line change
`@@ -1,24 +1,26 @@`
`1`	`1`	`#include "../Headers/0003_Graph/0001_BreadthFirstSearch.h"`
`2`	`2`	`#include<iostream>`
`3`	`3`	`#include<queue>`
	`4`	`+#include<vector>`
	`5`	`+#include<utility>`
`4`	`6`	`#include<string>`
`5`	`7`	`#include<climits>`
`6`	`8`	`using namespace std;`
`7`	`9`
`8`		`-Node::Node(char value)`
	`10`	`+BFSNode::BFSNode(char value)`
`9`	`11`	`{`
`10`	`12`	`this->data = value;`
`11`		`- distance = INT_MAX;`
`12`		`- color = WHITE;`
`13`		`- parent = NULL;`
	`13`	`+ this->distance = INT_MAX;`
	`14`	`+ this->color = WHITE;`
	`15`	`+ this->parent = nullptr;`
`14`	`16`	`}`
`15`	`17`
`16`		`-Node* BFSGraph::MakeOrFindNode(char value)`
	`18`	`+BFSNode* BFSGraph::MakeOrFindNode(char value)`
`17`	`19`	`{`
`18`		`- Node* node = NULL;`
	`20`	`+ BFSNode* node = nullptr;`
`19`	`21`	`if (this->_nodeMap.find(value) == this->_nodeMap.end())`
`20`	`22`	`{`
`21`		`- node = new Node(value);`
	`23`	`+ node = new BFSNode(value);`
`22`	`24`	`this->_nodeMap[value] = node;`
`23`	`25`	`}`
`24`	`26`	`else`
`@@ -28,21 +30,21 @@ Node* BFSGraph::MakeOrFindNode(char value)`
`28`	`30`	`return node;`
`29`	`31`	`}`
`30`	`32`
`31`		`-void BFSGraph::BreadthFirstSearch(Node* node)`
	`33`	`+void BFSGraph::BreadthFirstSearch(BFSNode* node)`
`32`	`34`	`{`
`33`	`35`	`node->color = WHITE;`
`34`	`36`	`node->distance = 0;`
`35`		`- node->parent = NULL;`
	`37`	`+ node->parent = nullptr;`
`36`	`38`
`37`		`- queue<Node*> nodeQueue;`
	`39`	`+ queue<BFSNode*> nodeQueue;`
`38`	`40`	`nodeQueue.push(node);`
`39`	`41`
`40`	`42`	`while (nodeQueue.empty()!=true)`
`41`	`43`	`{`
`42`		`- Node* currentNode = nodeQueue.front();`
	`44`	`+ BFSNode* currentNode = nodeQueue.front();`
`43`	`45`	`nodeQueue.pop();`
`44`	`46`
`45`		`- for (auto adjacentNode : this->_adjlist[currentNode])`
	`47`	`+ for (auto &adjacentNode : this->_adjlist[currentNode])`
`46`	`48`	`{`
`47`	`49`	`if (adjacentNode->color == WHITE)`
`48`	`50`	`{`
`@@ -58,8 +60,8 @@ void BFSGraph::BreadthFirstSearch(Node* node)`
`58`	`60`
`59`	`61`	`void BFSGraph::PushUndirectedEdge(char valueU, char valueV)`
`60`	`62`	`{`
`61`		`- Node* nodeU = this->MakeOrFindNode(valueU);`
`62`		`- Node* nodeV = this->MakeOrFindNode(valueV);`
	`63`	`+ BFSNode* nodeU = this->MakeOrFindNode(valueU);`
	`64`	`+ BFSNode* nodeV = this->MakeOrFindNode(valueV);`
`63`	`65`
`64`	`66`	`this->_adjlist[nodeU].push_back(nodeV);`
`65`	`67`	`this->_adjlist[nodeV].push_back(nodeU);`
`@@ -70,12 +72,12 @@ void BFSGraph::BFS(char value)`
`70`	`72`	`this->BreadthFirstSearch(this->_nodeMap[value]);`
`71`	`73`	`}`
`72`	`74`
`73`		`-string BFSGraph::ShowBFSResult()`
	`75`	`+vector<pair<char, int>> BFSGraph::ShowBFSResult()`
`74`	`76`	`{`
`75`		`- string result = "";`
`76`		`- for (auto value : this->_nodeMap)`
	`77`	`+ vector<pair<char, int>> result;`
	`78`	`+ for (auto& node : this->_nodeMap)`
`77`	`79`	`{`
`78`		`- result = result + " " + value.first + "(" + to_string(value.second->distance) + ")";`
	`80`	`+ result.push_back(make_pair(node.first, node.second->distance));`
`79`	`81`	`}`
`80`	`82`	`return result;`
`81`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`# Specify the source files`
`2`	`2`	`set(0003GRAPH_SOURCES`
`3`	`3`	`0001_BreadthFirstSearch.cc`
	`4`	`+ 0002_DepthFirstSearch.cc`
`4`	`5`	`)`
`5`	`6`
`6`	`7`	`# Create a library target`
Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,11 @@ class UnitTestHelper`
`12`	`12`	`string VerifyVectorResult(vector<T> vector)`
`13`	`13`	`{`
`14`	`14`	`string result = "";`
`15`		`- for (auto iterator : vector)`
	`15`	`+ for (auto& iterator : vector)`
`16`	`16`	`{`
`17`	`17`	`result += to_string(iterator) + " ";`
`18`	`18`	`}`
`19`	`19`	`result.pop_back();`
`20`	`20`	`return result;`
`21`	`21`	`}`
`22`		`-};`
	`22`	`+};`