Merge pull request #28 from Debashis08/release

Release

Author: Debashis08

Headers/0002_Tree/0001_BinarySearchTree.h

@@ -3,43 +3,47 @@
 #include<vector>
 #include<string>
 using namespace std;
-class Node
+
+namespace BinarySearchTree
 {
-public:
-	int data;
-	Node* parent;
-	Node* left;
-	Node* right;
+	class Node
+	{
+	public:
+		int data;
+		Node* parent;
+		Node* left;
+		Node* right;
 
-	Node(int data, Node* parent, Node* left, Node* right);
-};
+		Node(int data, Node* parent, Node* left, Node* right);
+	};
 
-class BinarySearchTree
-{
-private:
-	Node* _root;
-	void _InsertNode(Node* node);
-	Node* _FindNode(int value);
-	Node* _FindMinimumValueNode(Node* node);
-	Node* _FindMaximumValueNode(Node* node);
-	Node* _FindSuccessorNode(Node* node);
-	Node* _FindPredecessorNode(Node* node);
-	void _Transplant(Node* nodeU, Node* nodeV);
-	void _DeleteNode(Node* node);
-	void _RecursiveInorderTraversal(Node* node, vector<int>& result);
-	void _RecursivePreorderTraversal(Node* node, vector<int>& result);
-	void _RecursivePostorderTraversal(Node* node, vector<int>& result);
-	void _MorrisInorderTraversal(Node* node, vector<int>& result);
-	void _MorrisPreorderTraversal(Node* node, vector<int>& result);
-	void _MorrisPostorderTraversal(Node* node, vector<int>& result);
-public:
-	BinarySearchTree();
-	void InsertNode(int value);
-	void DeleteNode(int value);
-	vector<int> GetRecursiveInorderTravesalResult();
-	vector<int> GetRecursivePreorderTravesalResult();
-	vector<int> GetRecursivePostorderTravesalResult();
-	vector<int> GetMorrisInorderTraversalResult();
-	vector<int> GetMorrisPreorderTraversalResult();
-	vector<int> GetMorrisPostorderTraversalResult();
-};
+	class BinarySearchTree
+	{
+	private:
+		Node* _root;
+		void _InsertNode(Node* node);
+		Node* _FindNode(int value);
+		Node* _FindMinimumValueNode(Node* node);
+		Node* _FindMaximumValueNode(Node* node);
+		Node* _FindSuccessorNode(Node* node);
+		Node* _FindPredecessorNode(Node* node);
+		void _Transplant(Node* nodeU, Node* nodeV);
+		void _DeleteNode(Node* node);
+		void _RecursiveInorderTraversal(Node* node, vector<int>& result);
+		void _RecursivePreorderTraversal(Node* node, vector<int>& result);
+		void _RecursivePostorderTraversal(Node* node, vector<int>& result);
+		void _MorrisInorderTraversal(Node* node, vector<int>& result);
+		void _MorrisPreorderTraversal(Node* node, vector<int>& result);
+		void _MorrisPostorderTraversal(Node* node, vector<int>& result);
+	public:
+		BinarySearchTree();
+		void InsertNode(int value);
+		void DeleteNode(int value);
+		vector<int> GetRecursiveInorderTravesalResult();
+		vector<int> GetRecursivePreorderTravesalResult();
+		vector<int> GetRecursivePostorderTravesalResult();
+		vector<int> GetMorrisInorderTraversalResult();
+		vector<int> GetMorrisPreorderTraversalResult();
+		vector<int> GetMorrisPostorderTraversalResult();
+	};
+}

Headers/0003_Graph/0001_BreadthFirstSearch.h

@@ -6,27 +6,30 @@
 #include<string>
 #include<vector>
 using namespace std;
-enum color { WHITE, GRAY, BLACK };
 
-class BFSNode
+namespace BreadthFirstSearch
 {
-public:
-    int data;
-    int distance;
-    int color;
-    BFSNode* parent;
-    BFSNode(int value);
-};
+    enum color { WHITE, GRAY, BLACK };
+    class Node
+    {
+    public:
+        int data;
+        int distance;
+        int color;
+        Node* parent;
+        Node(int value);
+    };
 
-class BFSGraph
-{
-private:
-    map<BFSNode*, list<BFSNode*>> _adjlist;
-    map<int, BFSNode*> _nodeMap;
-    BFSNode* MakeOrFindNode(int value);
-    void BreadthFirstSearch(BFSNode* node);
-public:
-    void PushUndirectedEdge(int valueU, int valueV);
-    void BFS(int value);
-    vector<pair<int, int>> ShowBFSResult();
-};
+    class Graph
+    {
+    private:
+        map<Node*, list<Node*>> _adjlist;
+        map<int, Node*> _nodeMap;
+        Node* MakeOrFindNode(int value);
+        void BreadthFirstSearch(Node* node);
+    public:
+        void PushUndirectedEdge(int valueU, int valueV);
+        void BFS(int value);
+        vector<pair<int, int>> ShowBFSResult();
+    };
+}

Headers/0003_Graph/0002_DepthFirstSearch.h

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

Headers/0003_Graph/0003_TopologicalSort.h

@@ -5,32 +5,36 @@
 #include<string>
 #include<vector>
 using namespace std;
-enum color { WHITE, GRAY, BLACK };
 
-class TopologicalSortNode
+namespace TopologicalSort
 {
-public:
-    int data;
-    int color;
-    int discoveryTime;
-    int finishingTime;
-    TopologicalSortNode* parent;
-    TopologicalSortNode(int value);
-};
+    enum color { WHITE, GRAY, BLACK };
 
-class TopologicalSortGraph
-{
-private:
-    int time;
-    bool hasCycle;
-    map<TopologicalSortNode*, list<TopologicalSortNode*>> _adjlist;
-    map<int, TopologicalSortNode*> _nodeMap;
-    list<TopologicalSortNode*> _topologicalSortedNodeList;
-    TopologicalSortNode* MakeOrFindNode(int value);
-    void DepthFirstSearch(TopologicalSortNode* DFSNode);
-public:
-    void PushDirectedEdge(int valueU, int valueV);
-    void PushSingleNode(int valueU);
-    void TopologicalSort();
-    vector<pair<int, pair<int, int>>> ShowTopologicalSortResult();
-};
+    class Node
+    {
+    public:
+        int data;
+        int color;
+        int discoveryTime;
+        int finishingTime;
+        Node* parent;
+        Node(int value);
+    };
+
+    class Graph
+    {
+    private:
+        int time;
+        bool hasCycle;
+        map<Node*, list<Node*>> _adjlist;
+        map<int, Node*> _nodeMap;
+        list<Node*> _topologicalSortedNodeList;
+        Node* MakeOrFindNode(int value);
+        void DepthFirstSearch(Node* DFSNode);
+    public:
+        void PushDirectedEdge(int valueU, int valueV);
+        void PushSingleNode(int valueU);
+        void TopologicalSort();
+        vector<pair<int, pair<int, int>>> ShowTopologicalSortResult();
+    };
+}

Headers/0003_Graph/0004_StronglyConnectedComponents.h

@@ -5,35 +5,39 @@
 #include<string>
 #include<vector>
 using namespace std;
-enum color { WHITE, GRAY, BLACK };
 
-class SCCNode
+namespace StronglyConnectedComponents
 {
-public:
-    int data;
-    int color;
-    int discoveryTime;
-    int finishingTime;
-    SCCNode* parent;
-    SCCNode(int value);
-};
+    enum color { WHITE, GRAY, BLACK };
 
-class StronglyConnectedComponentsGraph
-{
-private:
-    int time;
-    map<SCCNode*, list<SCCNode*>> _adjlistG;
-    map<SCCNode*, list<SCCNode*>> _adjlistT;
-    map<int, SCCNode*> _nodeMap;
-    list<SCCNode*> _nodesFinishingTimeOrder;
-    vector<vector<int>> _allConnectedComponents;
-    SCCNode* MakeOrFindNode(int value);
-    void DepthFirstSearchOnGraphG(SCCNode* DFSNode);
-    void DepthFirstSearchOnGraphT(SCCNode* DFSNode, vector<int>& connectedComponents);
-public:
-    void PushDirectedEdge(int valueU, int valueV);
-    void PushSingleNode(int valueU);
-    void DFSOnGraphG();
-    void DFSOnGraphT();
-    vector<vector<int>> FindAllStronglyConnectedComponents();
-};
+    class Node
+    {
+    public:
+        int data;
+        int color;
+        int discoveryTime;
+        int finishingTime;
+        Node* parent;
+        Node(int value);
+    };
+
+    class Graph
+    {
+    private:
+        int time;
+        map<Node*, list<Node*>> _adjlistG;
+        map<Node*, list<Node*>> _adjlistT;
+        map<int, Node*> _nodeMap;
+        list<Node*> _nodesFinishingTimeOrder;
+        vector<vector<int>> _allConnectedComponents;
+        Node* MakeOrFindNode(int value);
+        void DepthFirstSearchOnGraphG(Node* DFSNode);
+        void DepthFirstSearchOnGraphT(Node* DFSNode, vector<int>& connectedComponents);
+    public:
+        void PushDirectedEdge(int valueU, int valueV);
+        void PushSingleNode(int valueU);
+        void DFSOnGraphG();
+        void DFSOnGraphT();
+        vector<vector<int>> FindAllStronglyConnectedComponents();
+    };
+}

Headers/0003_Graph/0005_HamiltonianPathAndCycle.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include<map>
+#include<unordered_set>
+#include<vector>
+using namespace std;
+
+namespace HamiltonianPathAndCycle
+{
+	class Node
+	{
+	public:
+		int data;
+		bool isVisited;
+		Node(int value);
+	};
+
+	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();
+	};
+}