dfs logic, and test added

Author: Debashis08

Headers/0003_Graph/0002_DepthFirstSearch.h

@@ -3,28 +3,31 @@
 #include<list>
 #include<map>
 #include<string>
+#include<vector>
 using namespace std;
 enum color { WHITE, GRAY, BLACK };
 
-class Node
+class DFSNode
 {
 public:
     char data;
-    int distance;
     int color;
-    Node* parent;
-    Node(char value);
+    int discoveredTime;
+    int finishingTime;
+    DFSNode* parent;
+    DFSNode(char value);
 };
 
 class DFSGraph
 {
 private:
-    map<Node*, list<Node*>> _adjlist;
-    map<char, Node*> _nodeMap;
-    Node* MakeOrFindNode(char value);
-    void DepthFirstSearch(Node* node);
+    int time;
+    map<DFSNode*, list<DFSNode*>> _adjlist;
+    map<char, DFSNode*> _nodeMap;
+    DFSNode* MakeOrFindNode(char value);
+    void DepthFirstSearch(DFSNode* DFSNode);
 public:
-    void PushUndirectedEdge(char valueU, char valueV);
-    void DFS(char value);
-    string ShowDFSResult();
+    void PushDirectedEdge(char valueU, char valueV);
+    void DFS();
+    vector<pair<char,pair<int,int>>> ShowDFSResult();
 };

SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc

@@ -10,14 +10,14 @@ using namespace std;
 Node::Node(char value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
 {
 	this->data = value;
-	distance = INT_MAX;
-	color = WHITE;
-	parent = NULL;
+	this->distance = INT_MAX;
+	this->color = WHITE;
+	this->parent = nullptr;
 }
 
 Node* Graph::MakeOrFindNode(char value)
 {
-	Node* node = NULL;
+	Node* node = nullptr;
 	if (this->_nodeMap.find(value) == this->_nodeMap.end())
 	{
 		node = new Node(value);
@@ -34,7 +34,7 @@ void Graph::BreadthFirstSearch(Node* node)
 {
 	node->color = WHITE;
 	node->distance = 0;
-	node->parent = NULL;
+	node->parent = nullptr;
 
 	queue<Node*> nodeQueue;
 	nodeQueue.push(node);

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;
+}

Tests/0000_CommonUtilities/UnitTestHelperVectorOfPair.h

@@ -24,4 +24,19 @@ class UnitTestHelperVectorOfPair
 		}
 		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;
+	}
 };

Tests/0003_Graph/0002_DepthFirstSearchTest.cc

@@ -1,7 +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);
+    }
 }