fix: code style fix for clang-tidy ci-cd check

Author: Debashis08

Headers/0002_Tree/0001_BinarySearchTree.h

@@ -21,20 +21,20 @@ namespace 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);
+		void InsertBinarySearchTreeNode(Node* node);
+		Node* FindBinarySearchTreeNode(int value);
+		Node* FindBinarySearchTreeMinimumValueNode(Node* node);
+		Node* FindBinarySearchTreeMaximumValueNode(Node* node);
+		Node* FindSuccessorBinarySearchTreeNode(Node* node);
+		Node* FindPredecessorBinarySearchTreeNode(Node* node);
+		void TransplantBinarySearchTreeNode(Node* nodeU, Node* nodeV);
+		void DeleteBinarySearchTreeNode(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);

Headers/0003_Graph/0002_DepthFirstSearch.h

@@ -24,7 +24,7 @@ namespace DepthFirstSearch
     class Graph
     {
     private:
-        int time;
+        int _time;
         map<Node*, list<Node*>> _adjlist;
         map<int, Node*> _nodeMap;
         Node* MakeOrFindNode(int value);

Headers/0003_Graph/0003_TopologicalSort.h

@@ -25,8 +25,8 @@ namespace TopologicalSort
     class Graph
     {
     private:
-        int time;
-        bool hasCycle;
+        int _time;
+        bool _hasCycle;
         map<Node*, list<Node*>> _adjlist;
         map<int, Node*> _nodeMap;
         list<Node*> _topologicalSortedNodeList;

Headers/0003_Graph/0004_StronglyConnectedComponents.h

@@ -24,7 +24,7 @@ namespace StronglyConnectedComponents
     class Graph
     {
     private:
-        int time;
+        int _time;
         map<Node*, list<Node*>> _adjlistG;
         map<Node*, list<Node*>> _adjlistT;
         map<int, Node*> _nodeMap;

SourceCodes/0001_Basics/Node.cc

@@ -1,5 +1,4 @@
 #include "../Headers/0001_Basics/Node.h"
-using namespace std;
 
 Node::Node()
 {

SourceCodes/0002_Tree/0001_BinarySearchTree.cc

@@ -19,7 +19,7 @@ namespace BinarySearchTree
 	}
 
 
-	void BinarySearchTree::_InsertNode(Node* node)
+	void BinarySearchTree::InsertBinarySearchTreeNode(Node* node)
 	{
 		Node* nodeY = nullptr;
 		Node* nodeX = this->_root;
@@ -50,7 +50,7 @@ namespace BinarySearchTree
 		}
 	}
 
-	Node* BinarySearchTree::_FindNode(int value)
+	Node* BinarySearchTree::FindBinarySearchTreeNode(int value)
 	{
 		Node* node = this->_root;
 		while (node != nullptr)
@@ -71,7 +71,7 @@ namespace BinarySearchTree
 		return node;
 	}
 
-	Node* BinarySearchTree::_FindMinimumValueNode(Node* node)
+	Node* BinarySearchTree::FindBinarySearchTreeMinimumValueNode(Node* node)
 	{
 		while (node->left != nullptr)
 		{
@@ -80,7 +80,7 @@ namespace BinarySearchTree
 		return node;
 	}
 
-	Node* BinarySearchTree::_FindMaximumValueNode(Node* node)
+	Node* BinarySearchTree::FindBinarySearchTreeMaximumValueNode(Node* node)
 	{
 		while (node->right != nullptr)
 		{
@@ -89,11 +89,11 @@ namespace BinarySearchTree
 		return node;
 	}
 
-	Node* BinarySearchTree::_FindSuccessorNode(Node* node)
+	Node* BinarySearchTree::FindSuccessorBinarySearchTreeNode(Node* node)
 	{
 		if (node->right != nullptr)
 		{
-			return this->_FindMinimumValueNode(node->right);
+			return this->FindBinarySearchTreeMinimumValueNode(node->right);
 		}
 		Node* nodeY = node->parent;
 		while (nodeY != nullptr && node == nodeY->right)
@@ -104,11 +104,11 @@ namespace BinarySearchTree
 		return nodeY;
 	}
 
-	Node* BinarySearchTree::_FindPredecessorNode(Node* node)
+	Node* BinarySearchTree::FindPredecessorBinarySearchTreeNode(Node* node)
 	{
 		if (node->left != nullptr)
 		{
-			return this->_FindMaximumValueNode(node->left);
+			return this->FindBinarySearchTreeMaximumValueNode(node->left);
 		}
 		Node* nodeY = node->parent;
 		while (nodeY != nullptr && node == nodeY->left)
@@ -119,7 +119,7 @@ namespace BinarySearchTree
 		return nodeY;
 	}
 
-	void BinarySearchTree::_Transplant(Node* nodeU, Node* nodeV)
+	void BinarySearchTree::TransplantBinarySearchTreeNode(Node* nodeU, Node* nodeV)
 	{
 		if (nodeU->parent == nullptr)
 		{
@@ -140,66 +140,66 @@ namespace BinarySearchTree
 		}
 	}
 
-	void BinarySearchTree::_DeleteNode(Node* node)
+	void BinarySearchTree::DeleteBinarySearchTreeNode(Node* node)
 	{
 		if (node->left == nullptr)
 		{
-			this->_Transplant(node, node->right);
+			this->TransplantBinarySearchTreeNode(node, node->right);
 		}
 		else if (node->right == nullptr)
 		{
-			this->_Transplant(node, node->left);
+			this->TransplantBinarySearchTreeNode(node, node->left);
 		}
 		else
 		{
-			Node* nodeY = this->_FindMinimumValueNode(node->right);
+			Node* nodeY = this->FindBinarySearchTreeMinimumValueNode(node->right);
 			if (nodeY->parent != node)
 			{
-				this->_Transplant(nodeY, nodeY->right);
+				this->TransplantBinarySearchTreeNode(nodeY, nodeY->right);
 				nodeY->right = node->right;
 				nodeY->right->parent = nodeY;
 			}
-			this->_Transplant(node, nodeY);
+			this->TransplantBinarySearchTreeNode(node, nodeY);
 			nodeY->left = node->left;
 			nodeY->left->parent = nodeY;
 			delete node;
 		}
 	}
 
-	void BinarySearchTree::_RecursiveInorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::RecursiveInorderTraversal(Node* node, vector<int>& result)
 	{
 		if (node == nullptr)
 		{
 			return;
 		}
-		this->_RecursiveInorderTraversal(node->left, result);
+		this->RecursiveInorderTraversal(node->left, result);
 		result.push_back(node->data);
-		this->_RecursiveInorderTraversal(node->right, result);
+		this->RecursiveInorderTraversal(node->right, result);
 	}
 
-	void BinarySearchTree::_RecursivePreorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::RecursivePreorderTraversal(Node* node, vector<int>& result)
 	{
 		if (node == nullptr)
 		{
 			return;
 		}
 		result.push_back(node->data);
-		this->_RecursivePreorderTraversal(node->left, result);
-		this->_RecursivePreorderTraversal(node->right, result);
+		this->RecursivePreorderTraversal(node->left, result);
+		this->RecursivePreorderTraversal(node->right, result);
 	}
 
-	void BinarySearchTree::_RecursivePostorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::RecursivePostorderTraversal(Node* node, vector<int>& result)
 	{
 		if (node == nullptr)
 		{
 			return;
 		}
-		this->_RecursivePostorderTraversal(node->left, result);
-		this->_RecursivePostorderTraversal(node->right, result);
+		this->RecursivePostorderTraversal(node->left, result);
+		this->RecursivePostorderTraversal(node->right, result);
 		result.push_back(node->data);
 	}
 
-	void BinarySearchTree::_MorrisInorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::MorrisInorderTraversal(Node* node, vector<int>& result)
 	{
 		while (node != nullptr)
 		{
@@ -230,7 +230,7 @@ namespace BinarySearchTree
 		}
 	}
 
-	void BinarySearchTree::_MorrisPreorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::MorrisPreorderTraversal(Node* node, vector<int>& result)
 	{
 		while (node != nullptr)
 		{
@@ -261,7 +261,7 @@ namespace BinarySearchTree
 		}
 	}
 
-	void BinarySearchTree::_MorrisPostorderTraversal(Node* node, vector<int>& result)
+	void BinarySearchTree::MorrisPostorderTraversal(Node* node, vector<int>& result)
 	{
 		while (node != nullptr)
 		{
@@ -296,54 +296,54 @@ namespace BinarySearchTree
 	void BinarySearchTree::InsertNode(int value)
 	{
 		Node* node = new Node(value, nullptr, nullptr, nullptr);
-		this->_InsertNode(node);
+		this->InsertBinarySearchTreeNode(node);
 	}
 
 	void BinarySearchTree::DeleteNode(int value)
 	{
-		Node* node = this->_FindNode(value);
-		this->_DeleteNode(node);
+		Node* node = this->FindBinarySearchTreeNode(value);
+		this->DeleteBinarySearchTreeNode(node);
 	}
 
 	vector<int> BinarySearchTree::GetRecursiveInorderTravesalResult()
 	{
 		vector<int> result;
-		this->_RecursiveInorderTraversal(this->_root, result);
+		this->RecursiveInorderTraversal(this->_root, result);
 		return result;
 	}
 
 	vector<int> BinarySearchTree::GetRecursivePreorderTravesalResult()
 	{
 		vector<int> result;
-		this->_RecursivePreorderTraversal(this->_root, result);
+		this->RecursivePreorderTraversal(this->_root, result);
 		return result;
 	}
 
 	vector<int> BinarySearchTree::GetRecursivePostorderTravesalResult()
 	{
 		vector<int> result;
-		this->_RecursivePostorderTraversal(this->_root, result);
+		this->RecursivePostorderTraversal(this->_root, result);
 		return result;
 	}
 
 	vector<int> BinarySearchTree::GetMorrisInorderTraversalResult()
 	{
 		vector<int> result;
-		this->_MorrisInorderTraversal(this->_root, result);
+		this->MorrisInorderTraversal(this->_root, result);
 		return result;
 	}
 
 	vector<int> BinarySearchTree::GetMorrisPreorderTraversalResult()
 	{
 		vector<int> result;
-		this->_MorrisPreorderTraversal(this->_root, result);
+		this->MorrisPreorderTraversal(this->_root, result);
 		return result;
 	}
 
 	vector<int> BinarySearchTree::GetMorrisPostorderTraversalResult()
 	{
 		vector<int> result;
-		this->_MorrisPostorderTraversal(this->_root, result);
+		this->MorrisPostorderTraversal(this->_root, result);
 		return result;
 	}
 }

SourceCodes/0003_Graph/0002_DepthFirstSearch.cc

@@ -32,8 +32,8 @@ namespace DepthFirstSearch
 
 	void Graph::DepthFirstSearch(Node* nodeU)
 	{
-		this->time++;
-		nodeU->discoveredTime = this->time;
+		this->_time++;
+		nodeU->discoveredTime = this->_time;
 		nodeU->color = GRAY;
 		for (auto nodeV : this->_adjlist[nodeU])
 		{
@@ -44,8 +44,8 @@ namespace DepthFirstSearch
 			}
 		}
 		nodeU->color = BLACK;
-		this->time++;
-		nodeU->finishingTime = time;
+		this->_time++;
+		nodeU->finishingTime = this->_time;
 	}
 
 	void Graph::PushDirectedEdge(int valueU, int valueV)
@@ -58,7 +58,7 @@ namespace DepthFirstSearch
 
 	void Graph::DFS()
 	{
-		this->time = 0;
+		this->_time = 0;
 		for (auto& iterator : this->_nodeMap)
 		{
 			if (iterator.second->color == WHITE)