Feature graph implementation

Headers/0003_Graph/0001_BreadthFirstSearch.h

@@ -1,35 +1,30 @@
 #pragma once
 
-#include<map>
 #include<list>
+#include<map>
+#include<string>
 using namespace std;
 enum color { WHITE, GRAY, BLACK };
+
 class Node
 {
 public:
     char data;
     int distance;
     int color;
     Node* parent;
-    Node(char val);
-};
-
-class CompareNodes
-{
-public:
-    bool operator()(Node* temp_u, Node* temp_v);
+    Node(char value);
 };
 
 class BFSGraph
 {
 private:
-    map<Node*, list<Node*>, CompareNodes> adjlist;
-    list<Node*> node_list;
-    Node* find_node_in_list(char val);
-    void graph_bfs(Node* node);
+    map<Node*, list<Node*>> _adjlist;
+    map<char, Node*> _nodeMap;
+    Node* MakeOrFindNode(char value);
+    void BreadthFirstSearch(Node* node);
 public:
-    void push_edge(char val_u, char val_v);
-    void show_graph_data();
-    void bfs(char val);
-    void show_bfs_result();
+    void PushUndirectedEdge(char valueU, char valueV);
+    void BFS(char value);
+    string ShowBFSResult();
 };

SourceCodes/0003_Graph/0001_BreadthFirstSearch.cc

@@ -1,15 +1,80 @@
 #include "../Headers/0003_Graph/0001_BreadthFirstSearch.h"
+#include<iostream>
+#include<queue>
+#include<string>
 using namespace std;
 
-Node::Node(char val)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
+Node::Node(char value)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
 {
-	this->data = val;
+	this->data = value;
 	distance = INT_MAX;
 	color = WHITE;
 	parent = NULL;
 }
 
-bool CompareNodes::operator()(Node* temp_u, Node* temp_v)
+Node* BFSGraph::MakeOrFindNode(char value)
 {
-	return (temp_u->data < temp_v->data);
+	Node* node = NULL;
+	if (this->_nodeMap.find(value) == this->_nodeMap.end())
+	{
+		node = new Node(value);
+		this->_nodeMap[value] = node;
+	}
+	else
+	{
+		node = this->_nodeMap[value];
+	}
+	return node;
+}
+
+void BFSGraph::BreadthFirstSearch(Node* node)
+{
+	node->color = WHITE;
+	node->distance = 0;
+	node->parent = NULL;
+
+	queue<Node*> nodeQueue;
+	nodeQueue.push(node);
+
+	while (nodeQueue.empty()!=true)
+	{
+		Node* currentNode = nodeQueue.front();
+		nodeQueue.pop();
+
+		for (auto adjacentNode : this->_adjlist[currentNode])
+		{
+			if (adjacentNode->color == WHITE)
+			{
+				adjacentNode->color = GRAY;
+				adjacentNode->parent = currentNode;
+				adjacentNode->distance = currentNode->distance + 1;
+				nodeQueue.push(adjacentNode);
+			}
+		}
+		currentNode->color = BLACK;
+	}
+}
+
+void BFSGraph::PushUndirectedEdge(char valueU, char valueV)
+{
+	Node* nodeU = this->MakeOrFindNode(valueU);
+	Node* nodeV = this->MakeOrFindNode(valueV);
+
+	this->_adjlist[nodeU].push_back(nodeV);
+	this->_adjlist[nodeV].push_back(nodeU);
+}
+
+void BFSGraph::BFS(char value)
+{
+	this->BreadthFirstSearch(this->_nodeMap[value]);
+}
+
+string BFSGraph::ShowBFSResult()
+{
+	string result = "";
+	for (auto value : this->_nodeMap)
+	{
+		result = result + " " + value.first + "(" + to_string(value.second->distance) + ")";
+	}
+	return result;
 }

Tests/0003_Graph/0001_BreadthFirstSearchTest.cc

@@ -0,0 +1,28 @@
+#include <gtest/gtest.h>
+#include<string>
+#include "../Headers/0003_Graph/0001_BreadthFirstSearch.h"
+
+// Demonstrate some basic assertions.
+namespace BreadthFirstSearchTest
+{
+	TEST(BFSTesting, ShowBFSResultTest) {
+		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');
+
+        string actualResult = graph.ShowBFSResult();
+        string expectedResult = " r(1) s(0) t(2) u(3) v(2) w(1) x(2) y(3)";
+        EXPECT_EQ(actualResult, expectedResult);
+	}
+}