graph data datatype changes

Debashis08 · Debashis08 · commit b41450704911 · 2024-10-17T23:15:18.000+05:30
diff --git a/Headers/0003_Graph/0001_BreadthFirstSearch.h b/Headers/0003_Graph/0001_BreadthFirstSearch.h
@@ -11,22 +11,22 @@ enum color { WHITE, GRAY, BLACK };
 class BFSNode
 {
 public:
-    char data;
+    int data;
     int distance;
     int color;
     BFSNode* parent;
-    BFSNode(char value);
+    BFSNode(int value);
 };
 
 class BFSGraph
 {
 private:
     map<BFSNode*, list<BFSNode*>> _adjlist;
-    map<char, BFSNode*> _nodeMap;
-    BFSNode* MakeOrFindNode(char value);
+    map<int, BFSNode*> _nodeMap;
+    BFSNode* MakeOrFindNode(int value);
     void BreadthFirstSearch(BFSNode* node);
 public:
-    void PushUndirectedEdge(char valueU, char valueV);
-    void BFS(char value);
-    vector<pair<char, int>> ShowBFSResult();
+    void PushUndirectedEdge(int valueU, int valueV);
+    void BFS(int value);
+    vector<pair<int, int>> ShowBFSResult();
 };
diff --git a/Headers/0003_Graph/0002_DepthFirstSearch.h b/Headers/0003_Graph/0002_DepthFirstSearch.h
@@ -10,24 +10,24 @@ enum color { WHITE, GRAY, BLACK };
 class DFSNode
 {
 public:
-    char data;
+    int data;
     int color;
     int discoveredTime;
     int finishingTime;
     DFSNode* parent;
-    DFSNode(char value);
+    DFSNode(int value);
 };
 
 class DFSGraph
 {
 private:
     int time;
     map<DFSNode*, list<DFSNode*>> _adjlist;
-    map<char, DFSNode*> _nodeMap;
-    DFSNode* MakeOrFindNode(char value);
+    map<int, DFSNode*> _nodeMap;
+    DFSNode* MakeOrFindNode(int value);
     void DepthFirstSearch(DFSNode* DFSNode);
 public:
-    void PushDirectedEdge(char valueU, char valueV);
+    void PushDirectedEdge(int valueU, int valueV);
     void DFS();
-    vector<pair<char,pair<int,int>>> ShowDFSResult();
+    vector<pair<int,pair<int,int>>> ShowDFSResult();
 };
diff --git a/SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc b/SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc
@@ -7,15 +7,15 @@
 #include<climits>
 using namespace std;
 
-BFSNode::BFSNode(char value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
+BFSNode::BFSNode(int value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
 {
 	this->data = value;
 	this->distance = INT_MAX;
 	this->color = WHITE;
 	this->parent = nullptr;
 }
 
-BFSNode* BFSGraph::MakeOrFindNode(char value)
+BFSNode* BFSGraph::MakeOrFindNode(int value)
 {
 	BFSNode* node = nullptr;
 	if (this->_nodeMap.find(value) == this->_nodeMap.end())
@@ -58,7 +58,7 @@ void BFSGraph::BreadthFirstSearch(BFSNode* node)
 	}
 }
 
-void BFSGraph::PushUndirectedEdge(char valueU, char valueV)
+void BFSGraph::PushUndirectedEdge(int valueU, int valueV)
 {
 	BFSNode* nodeU = this->MakeOrFindNode(valueU);
 	BFSNode* nodeV = this->MakeOrFindNode(valueV);
@@ -67,14 +67,14 @@ void BFSGraph::PushUndirectedEdge(char valueU, char valueV)
 	this->_adjlist[nodeV].push_back(nodeU);
 }
 
-void BFSGraph::BFS(char value)
+void BFSGraph::BFS(int value)
 {
 	this->BreadthFirstSearch(this->_nodeMap[value]);
 }
 
-vector<pair<char, int>> BFSGraph::ShowBFSResult()
+vector<pair<int, int>> BFSGraph::ShowBFSResult()
 {
-	vector<pair<char, int>> result;
+	vector<pair<int, int>> result;
 	for (auto& node : this->_nodeMap)
 	{
 		result.push_back(make_pair(node.first, node.second->distance));
diff --git a/SourceCodes/0003_Graph/0002_DepthFirstSearch.cc b/SourceCodes/0003_Graph/0002_DepthFirstSearch.cc
@@ -4,7 +4,7 @@
 #include<climits>
 using namespace std;
 
-DFSNode::DFSNode(char value)
+DFSNode::DFSNode(int value)
 {
 	this->data = value;
 	this->discoveredTime = INT_MAX;
@@ -13,7 +13,7 @@ DFSNode::DFSNode(char value)
 	this->parent = nullptr;
 }
 
-DFSNode* DFSGraph::MakeOrFindNode(char value)
+DFSNode* DFSGraph::MakeOrFindNode(int value)
 {
 	DFSNode* node = nullptr;
 	if (this->_nodeMap.find(value) == this->_nodeMap.end())
@@ -27,6 +27,7 @@ DFSNode* DFSGraph::MakeOrFindNode(char value)
 	}
 	return node;
 }
+
 void DFSGraph::DepthFirstSearch(DFSNode* nodeU)
 {
 	this->time++;
@@ -45,7 +46,7 @@ void DFSGraph::DepthFirstSearch(DFSNode* nodeU)
 	nodeU->finishingTime = time;
 }
 
-void DFSGraph::PushDirectedEdge(char valueU, char valueV)
+void DFSGraph::PushDirectedEdge(int valueU, int valueV)
 {
 	DFSNode* nodeU = this->MakeOrFindNode(valueU);
 	DFSNode* nodeV = this->MakeOrFindNode(valueV);
@@ -65,9 +66,9 @@ void DFSGraph::DFS()
 	}
 }
 
-vector<pair<char, pair<int, int>>> DFSGraph::ShowDFSResult()
+vector<pair<int, pair<int, int>>> DFSGraph::ShowDFSResult()
 {
-	vector<pair<char, pair<int, int>>> result;
+	vector<pair<int, pair<int, int>>> result;
 	for (auto& node : this->_nodeMap)
 	{
 		result.push_back(make_pair(node.first, make_pair(node.second->discoveredTime, node.second->finishingTime)));
diff --git a/Tests/0000_CommonUtilities/UnitTestHelper.h b/Tests/0000_CommonUtilities/UnitTestHelper.h
@@ -20,13 +20,29 @@ class UnitTestHelper
 		return result;
 	}
 
-	template<typename T1, typename T2>
-	string VerifyVectorResult(vector<pair<T1,T2>> vector)
+	template<typename T>
+	string VerifyVectorResult(vector<pair<T,T>> vector)
+	{
+		string result = "";
+		for (auto& iterator : vector)
+		{
+			result += to_string(iterator.first) + "(" + to_string(iterator.second) + ")" + " ";
+		}
+
+		if (!result.empty())
+		{
+			result.pop_back();
+		}
+		return result;
+	}
+	
+	template<typename T>
+	string VerifyVectorResult(vector<pair<T, pair<T, T>>> vector)
 	{
 		string result = "";
 		for (auto& iterator : vector)
 		{
-			result += string(1, iterator.first) + "(" + to_string(iterator.second) + ")" + " ";
+			result += to_string(iterator.first) + "(" + to_string(iterator.second.first) + "," + to_string(iterator.second.second) + ")" + " ";
 		}
 
 		if (!result.empty())
diff --git a/Tests/0000_CommonUtilities/UnitTestHelperVectorOfPair.h b/Tests/0000_CommonUtilities/UnitTestHelperVectorOfPair.h
diff --git a/Tests/0003_Graph/0001_BreadthFirstSearchTest.cc b/Tests/0003_Graph/0001_BreadthFirstSearchTest.cc
@@ -12,34 +12,34 @@ namespace BreadthFirstSearchTest
     {
 		BFSGraph graph;
 
-        graph.PushUndirectedEdge('s', 'r');
-        graph.PushUndirectedEdge('s', 'w');
-        graph.PushUndirectedEdge('r', 'v');
-        graph.PushUndirectedEdge('w', 't');
-        graph.PushUndirectedEdge('w', 'x');
-        graph.PushUndirectedEdge('t', 'x');
-        graph.PushUndirectedEdge('t', 'u');
-        graph.PushUndirectedEdge('x', 'u');
-        graph.PushUndirectedEdge('x', 'y');
-        graph.PushUndirectedEdge('u', 'y');
-
-        graph.BFS('s');
+        graph.PushUndirectedEdge(1, 2);
+        graph.PushUndirectedEdge(1, 3);
+        graph.PushUndirectedEdge(2, 4);
+        graph.PushUndirectedEdge(3, 5);
+        graph.PushUndirectedEdge(3, 6);
+        graph.PushUndirectedEdge(5, 6);
+        graph.PushUndirectedEdge(5, 7);
+        graph.PushUndirectedEdge(6, 7);
+        graph.PushUndirectedEdge(6, 8);
+        graph.PushUndirectedEdge(7, 8);
+
+        graph.BFS(1);
         
         string actualResult = unitTestHelper.VerifyVectorResult(graph.ShowBFSResult());
-        string expectedResult = "r(1) s(0) t(2) u(3) v(2) w(1) x(2) y(3)";
+        string expectedResult = "1(0) 2(1) 3(1) 4(2) 5(2) 6(2) 7(3) 8(3)";
         EXPECT_EQ(actualResult, expectedResult);
 	}
 
     TEST(BFSTesting, ShowBFSResultTest02) 
     {
         BFSGraph graph;
 
-        graph.PushUndirectedEdge('s', 'r');
+        graph.PushUndirectedEdge(1, 2);
 
-        graph.BFS('s');
+        graph.BFS(1);
 
         string actualResult = unitTestHelper.VerifyVectorResult(graph.ShowBFSResult());
-        string expectedResult = "r(1) s(0)";
+        string expectedResult = "1(0) 2(1)";
         EXPECT_EQ(actualResult, expectedResult);
     }
 }
diff --git a/Tests/0003_Graph/0002_DepthFirstSearchTest.cc b/Tests/0003_Graph/0002_DepthFirstSearchTest.cc

Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,15 @@`
`7`	`7`	`#include<climits>`
`8`	`8`	`using namespace std;`
`9`	`9`
`10`		`-BFSNode::BFSNode(char value)`
	`10`	`+BFSNode::BFSNode(int value)`
`11`	`11`	`{`
`12`	`12`	`this->data = value;`
`13`	`13`	`this->distance = INT_MAX;`
`14`	`14`	`this->color = WHITE;`
`15`	`15`	`this->parent = nullptr;`
`16`	`16`	`}`
`17`	`17`
`18`		`-BFSNode* BFSGraph::MakeOrFindNode(char value)`
	`18`	`+BFSNode* BFSGraph::MakeOrFindNode(int value)`
`19`	`19`	`{`
`20`	`20`	`BFSNode* node = nullptr;`
`21`	`21`	`if (this->_nodeMap.find(value) == this->_nodeMap.end())`
`@@ -58,7 +58,7 @@ void BFSGraph::BreadthFirstSearch(BFSNode* node)`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`		`-void BFSGraph::PushUndirectedEdge(char valueU, char valueV)`
	`61`	`+void BFSGraph::PushUndirectedEdge(int valueU, int valueV)`
`62`	`62`	`{`
`63`	`63`	`BFSNode* nodeU = this->MakeOrFindNode(valueU);`
`64`	`64`	`BFSNode* nodeV = this->MakeOrFindNode(valueV);`
`@@ -67,14 +67,14 @@ void BFSGraph::PushUndirectedEdge(char valueU, char valueV)`
`67`	`67`	`this->_adjlist[nodeV].push_back(nodeU);`
`68`	`68`	`}`
`69`	`69`
`70`		`-void BFSGraph::BFS(char value)`
	`70`	`+void BFSGraph::BFS(int value)`
`71`	`71`	`{`
`72`	`72`	`this->BreadthFirstSearch(this->_nodeMap[value]);`
`73`	`73`	`}`
`74`	`74`
`75`		`-vector<pair<char, int>> BFSGraph::ShowBFSResult()`
	`75`	`+vector<pair<int, int>> BFSGraph::ShowBFSResult()`
`76`	`76`	`{`
`77`		`- vector<pair<char, int>> result;`
	`77`	`+ vector<pair<int, int>> result;`
`78`	`78`	`for (auto& node : this->_nodeMap)`
`79`	`79`	`{`
`80`	`80`	`result.push_back(make_pair(node.first, node.second->distance));`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`#include<climits>`
`5`	`5`	`using namespace std;`
`6`	`6`
`7`		`-DFSNode::DFSNode(char value)`
	`7`	`+DFSNode::DFSNode(int value)`
`8`	`8`	`{`
`9`	`9`	`this->data = value;`
`10`	`10`	`this->discoveredTime = INT_MAX;`
`@@ -13,7 +13,7 @@ DFSNode::DFSNode(char value)`
`13`	`13`	`this->parent = nullptr;`
`14`	`14`	`}`
`15`	`15`
`16`		`-DFSNode* DFSGraph::MakeOrFindNode(char value)`
	`16`	`+DFSNode* DFSGraph::MakeOrFindNode(int value)`
`17`	`17`	`{`
`18`	`18`	`DFSNode* node = nullptr;`
`19`	`19`	`if (this->_nodeMap.find(value) == this->_nodeMap.end())`
`@@ -27,6 +27,7 @@ DFSNode* DFSGraph::MakeOrFindNode(char value)`
`27`	`27`	`}`
`28`	`28`	`return node;`
`29`	`29`	`}`
	`30`	`+`
`30`	`31`	`void DFSGraph::DepthFirstSearch(DFSNode* nodeU)`
`31`	`32`	`{`
`32`	`33`	`this->time++;`
`@@ -45,7 +46,7 @@ void DFSGraph::DepthFirstSearch(DFSNode* nodeU)`
`45`	`46`	`nodeU->finishingTime = time;`
`46`	`47`	`}`
`47`	`48`
`48`		`-void DFSGraph::PushDirectedEdge(char valueU, char valueV)`
	`49`	`+void DFSGraph::PushDirectedEdge(int valueU, int valueV)`
`49`	`50`	`{`
`50`	`51`	`DFSNode* nodeU = this->MakeOrFindNode(valueU);`
`51`	`52`	`DFSNode* nodeV = this->MakeOrFindNode(valueV);`
`@@ -65,9 +66,9 @@ void DFSGraph::DFS()`
`65`	`66`	`}`
`66`	`67`	`}`
`67`	`68`
`68`		`-vector<pair<char, pair<int, int>>> DFSGraph::ShowDFSResult()`
	`69`	`+vector<pair<int, pair<int, int>>> DFSGraph::ShowDFSResult()`
`69`	`70`	`{`
`70`		`- vector<pair<char, pair<int, int>>> result;`
	`71`	`+ vector<pair<int, pair<int, int>>> result;`
`71`	`72`	`for (auto& node : this->_nodeMap)`
`72`	`73`	`{`
`73`	`74`	`result.push_back(make_pair(node.first, make_pair(node.second->discoveredTime, node.second->finishingTime)));`