core: namespace added for ham cycle

Author: Debashis08

Headers/0003_Graph/0005_HamiltonianPathAndCycle.h

@@ -5,33 +5,36 @@
 #include<vector>
 using namespace std;
 
-class HamiltonianNode
+namespace HamiltonianPathAndCycle
 {
-public:
-	int data;
-	bool isVisited;
-	HamiltonianNode(int value);
-};
+	class Node
+	{
+	public:
+		int data;
+		bool isVisited;
+		Node(int value);
+	};
 
-class HamiltonianGraph
-{
-private:
-	bool _isHamiltonianCyclePresent;
-	bool _isHamiltonianPathPresent;
-	int _visitedNodeCount;
-	HamiltonianNode* _startingNode;
-	map<HamiltonianNode*, unordered_set<HamiltonianNode*>> _adjlist;
-	map<int, HamiltonianNode*> _nodeMap;
-	vector<int> _hamiltonianPath;
-	HamiltonianNode* MakeOrFindNode(int value);
-	bool IsSafe(HamiltonianNode* nodeU, HamiltonianNode* nodeV);
-	bool HamiltonianCycleAndPathUtil(HamiltonianNode* node);
+	class Graph
+	{
+	private:
+		bool _isHamiltonianCyclePresent;
+		bool _isHamiltonianPathPresent;
+		int _visitedNodeCount;
+		Node* _startingNode;
+		map<Node*, unordered_set<Node*>> _adjlist;
+		map<int, Node*> _nodeMap;
+		vector<int> _hamiltonianPath;
+		Node* MakeOrFindNode(int value);
+		bool IsSafe(Node* nodeU, Node* nodeV);
+		bool HamiltonianCycleAndPathUtil(Node* node);
 
-public:
-	void PushUndirectedEdge(int valueU, int valueV);
-	void PushSingleNode(int valueU);
-	void FindHamiltonianCycleAndPath();
-	bool IsHamiltonianCyclePresent();
-	bool IsHamiltonianPathPresent();
-	vector<int> GetHamiltonianPath();
-};
+	public:
+		void PushUndirectedEdge(int valueU, int valueV);
+		void PushSingleNode(int valueU);
+		void FindHamiltonianCycleAndPath();
+		bool IsHamiltonianCyclePresent();
+		bool IsHamiltonianPathPresent();
+		vector<int> GetHamiltonianPath();
+	};
+}

SourceCodes/0003_Graph/0005_HamiltonianPathAndCycle.cc

@@ -1,112 +1,114 @@
 #include "../Headers/0003_Graph/0005_HamiltonianPathAndCycle.h"
 
 using namespace std;
-
-HamiltonianNode::HamiltonianNode(int value)
-{
-	this->data = value;
-	this->isVisited = false;
-}
-
-// HamiltonianGraph Private Member Methods
-HamiltonianNode* HamiltonianGraph::MakeOrFindNode(int value)
+namespace HamiltonianPathAndCycle
 {
-	HamiltonianNode* node = nullptr;
-	if (this->_nodeMap.find(value) == this->_nodeMap.end())
+	Node::Node(int value)
 	{
-		node = new HamiltonianNode(value);
-		this->_nodeMap[value] = node;
+		this->data = value;
+		this->isVisited = false;
 	}
-	else
-	{
-		node = this->_nodeMap[value];
-	}
-	return node;
-}
 
-bool HamiltonianGraph::IsSafe(HamiltonianNode* nodeU, HamiltonianNode* nodeV)
-{
-	if (this->_adjlist[nodeU].find(nodeV) == this->_adjlist[nodeU].end())
+	// Graph Private Member Methods
+	Node* Graph::MakeOrFindNode(int value)
 	{
-		return false;
-	}
-	if (nodeV->isVisited == true)
-	{
-		return false;
+		Node* node = nullptr;
+		if (this->_nodeMap.find(value) == this->_nodeMap.end())
+		{
+			node = new Node(value);
+			this->_nodeMap[value] = node;
+		}
+		else
+		{
+			node = this->_nodeMap[value];
+		}
+		return node;
 	}
-	return true;
-}
 
-bool HamiltonianGraph::HamiltonianCycleAndPathUtil(HamiltonianNode* nodeU)
-{
-	if (this->_visitedNodeCount == this->_nodeMap.size())
+	bool Graph::IsSafe(Node* nodeU, Node* nodeV)
 	{
-		if (this->_adjlist[nodeU].find(this->_startingNode) != this->_adjlist[nodeU].end())
+		if (this->_adjlist[nodeU].find(nodeV) == this->_adjlist[nodeU].end())
 		{
-			this->_isHamiltonianCyclePresent = true;
-			this->_isHamiltonianPathPresent = true;
-			return true;
+			return false;
 		}
-		this->_isHamiltonianPathPresent = true;
-		return false;
+		if (nodeV->isVisited == true)
+		{
+			return false;
+		}
+		return true;
 	}
-	for (auto& nodeV : this->_adjlist[nodeU])
+
+	bool Graph::HamiltonianCycleAndPathUtil(Node* nodeU)
 	{
-		if (this->IsSafe(nodeU, nodeV))
+		if (this->_visitedNodeCount == this->_nodeMap.size())
 		{
-			this->_hamiltonianPath.push_back(nodeV->data);
-			nodeV->isVisited = true;
-			this->_visitedNodeCount++;
-			if (this->HamiltonianCycleAndPathUtil(nodeV))
+			if (this->_adjlist[nodeU].find(this->_startingNode) != this->_adjlist[nodeU].end())
 			{
+				this->_isHamiltonianCyclePresent = true;
+				this->_isHamiltonianPathPresent = true;
 				return true;
 			}
-			this->_visitedNodeCount--;
-			nodeV->isVisited = false;
-			this->_hamiltonianPath.pop_back();
+			this->_isHamiltonianPathPresent = true;
+			return false;
+		}
+		for (auto& nodeV : this->_adjlist[nodeU])
+		{
+			if (this->IsSafe(nodeU, nodeV))
+			{
+				this->_hamiltonianPath.push_back(nodeV->data);
+				nodeV->isVisited = true;
+				this->_visitedNodeCount++;
+				if (this->HamiltonianCycleAndPathUtil(nodeV))
+				{
+					return true;
+				}
+				this->_visitedNodeCount--;
+				nodeV->isVisited = false;
+				this->_hamiltonianPath.pop_back();
+			}
 		}
+		return false;
 	}
-	return false;
-}
 
-// HamiltonianGraph Public Member Methods
-void HamiltonianGraph::PushUndirectedEdge(int valueU, int valueV)
-{
-	HamiltonianNode* nodeU = this->MakeOrFindNode(valueU);
-	HamiltonianNode* nodeV = this->MakeOrFindNode(valueV);
+	// Graph Public Member Methods
+	void Graph::PushUndirectedEdge(int valueU, int valueV)
+	{
+		Node* nodeU = this->MakeOrFindNode(valueU);
+		Node* nodeV = this->MakeOrFindNode(valueV);
 
-	this->_adjlist[nodeU].insert(nodeV);
-	this->_adjlist[nodeV].insert(nodeU);
-}
+		this->_adjlist[nodeU].insert(nodeV);
+		this->_adjlist[nodeV].insert(nodeU);
+	}
 
-void HamiltonianGraph::PushSingleNode(int valueU)
-{
-	HamiltonianNode* nodeU = this->MakeOrFindNode(valueU);
-}
+	void Graph::PushSingleNode(int valueU)
+	{
+		Node* nodeU = this->MakeOrFindNode(valueU);
+	}
 
-void HamiltonianGraph::FindHamiltonianCycleAndPath()
-{
-	this->_isHamiltonianCyclePresent = false;
-	this->_isHamiltonianPathPresent = false;
-	this->_hamiltonianPath = {};
-	this->_startingNode = this->_nodeMap[0];
-	this->_hamiltonianPath.push_back(this->_startingNode->data);
-	this->_startingNode->isVisited = true;
-	this->_visitedNodeCount = 1;
-	this->HamiltonianCycleAndPathUtil(this->_startingNode);
-}
+	void Graph::FindHamiltonianCycleAndPath()
+	{
+		this->_isHamiltonianCyclePresent = false;
+		this->_isHamiltonianPathPresent = false;
+		this->_hamiltonianPath = {};
+		this->_startingNode = this->_nodeMap[0];
+		this->_hamiltonianPath.push_back(this->_startingNode->data);
+		this->_startingNode->isVisited = true;
+		this->_visitedNodeCount = 1;
+		this->HamiltonianCycleAndPathUtil(this->_startingNode);
+	}
 
-bool HamiltonianGraph::IsHamiltonianCyclePresent()
-{
-	return this->_isHamiltonianCyclePresent;
-}
+	bool Graph::IsHamiltonianCyclePresent()
+	{
+		return this->_isHamiltonianCyclePresent;
+	}
 
-bool HamiltonianGraph::IsHamiltonianPathPresent()
-{
-	return this->_isHamiltonianPathPresent;
-}
+	bool Graph::IsHamiltonianPathPresent()
+	{
+		return this->_isHamiltonianPathPresent;
+	}
 
-vector<int> HamiltonianGraph::GetHamiltonianPath()
-{
-	return this->_hamiltonianPath;
+	vector<int> Graph::GetHamiltonianPath()
+	{
+		return this->_hamiltonianPath;
+	}
 }

Tests/0003_Graph/0005_HamiltonianPathAndCycleTest.cc

@@ -2,13 +2,13 @@
 #include "../Headers/0003_Graph/0005_HamiltonianPathAndCycle.h"
 #include "../0000_CommonUtilities/UnitTestHelper.h"
 
-namespace HamiltonianPathAndCycleTest
+namespace HamiltonianPathAndCycle
 {
 	UnitTestHelper unitTestHelper;
 
 	TEST(HamiltonianCycleAndPathTest, ShowResult)
 	{
-		HamiltonianGraph graph;
+		Graph graph;
 
 		graph.PushUndirectedEdge(0, 1);
 		graph.PushUndirectedEdge(0, 3);