updated implementation and test cases

Debashis08 · Debashis08 · commit 3f342c79ef8f · 2024-09-22T22:31:52.000+05:30
diff --git a/Headers/0002_Tree/0001_BinarySearchTree.h b/Headers/0002_Tree/0001_BinarySearchTree.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include<vector>
 #include<string>
 using namespace std;
 class Node
@@ -25,20 +26,20 @@ class BinarySearchTree
 	Node* _FindPredecessorNode(Node* node);
 	void _Transplant(Node* nodeU, Node* nodeV);
 	void _DeleteNode(Node* node);
-	string _RecursiveInorderTraversal(Node* node);
-	string _RecursivePreorderTraversal(Node* node);
-	string _RecursivePostorderTraversal(Node* node);
-	string _MorrisInorderTraversal(Node* node);
-	string _MorrisPreorderTraversal(Node* node);
-	string _MorrisPostorderTraversal(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);
-	string GetRecursiveInorderTravesalResult();
-	string GetRecursivePreorderTravesalResult();
-	string GetRecursivePostorderTravesalResult();
-	string GetMorrisInorderTraversalResult();
-	string GetMorrisPreorderTraversalResult();
-	string GetMorrisPostorderTraversalResult();
+	vector<int> GetRecursiveInorderTravesalResult();
+	vector<int> GetRecursivePreorderTravesalResult();
+	vector<int> GetRecursivePostorderTravesalResult();
+	vector<int> GetMorrisInorderTraversalResult();
+	vector<int> GetMorrisPreorderTraversalResult();
+	vector<int> GetMorrisPostorderTraversalResult();
 };
diff --git a/SourceCodes/0002_Tree/0001_BinarySearchTree.cc b/SourceCodes/0002_Tree/0001_BinarySearchTree.cc
@@ -164,86 +164,46 @@ void BinarySearchTree::_DeleteNode(Node* node)
 	}
 }
 
-string BinarySearchTree::_RecursiveInorderTraversal(Node* node)
+void BinarySearchTree::_RecursiveInorderTraversal(Node* node, vector<int>& result)
 {
 	if (node == nullptr)
 	{
-		return "";
+		return;
 	}
-	string leftSubTree = this->_RecursiveInorderTraversal(node->left);
-	string currentNode = to_string(node->data);
-	string rightSubTree = this->_RecursiveInorderTraversal(node->right);
-
-	string result = leftSubTree;
-	if (!leftSubTree.empty())
-	{
-		result += " ";
-	}
-	result += currentNode;
-	if (!rightSubTree.empty())
-	{
-		result += " ";
-	}
-	result += rightSubTree;
-	return result;
+	this->_RecursiveInorderTraversal(node->left, result);
+	result.push_back(node->data);
+	this->_RecursiveInorderTraversal(node->right, result);
 }
 
-string BinarySearchTree::_RecursivePreorderTraversal(Node* node)
+void BinarySearchTree::_RecursivePreorderTraversal(Node* node, vector<int>& result)
 {
 	if (node == nullptr)
 	{
-		return "";
-	}
-	string currentNode = to_string(node->data);
-	string leftSubTree = this->_RecursivePreorderTraversal(node->left);
-	string rightSubTree = this->_RecursivePreorderTraversal(node->right);
-
-	string result = currentNode;
-	if (!leftSubTree.empty())
-	{
-		result += " ";
+		return;
 	}
-	result += leftSubTree;
-	if (!rightSubTree.empty())
-	{
-		result += " ";
-	}
-	result += rightSubTree;
-	return result;
+	result.push_back(node->data);
+	this->_RecursivePreorderTraversal(node->left, result);
+	this->_RecursivePreorderTraversal(node->right, result);
 }
 
-string BinarySearchTree::_RecursivePostorderTraversal(Node* node)
+void BinarySearchTree::_RecursivePostorderTraversal(Node* node, vector<int>& result)
 {
 	if (node == nullptr)
 	{
-		return "";
-	}
-	string leftSubTree = this->_RecursivePostorderTraversal(node->left);
-	string rightSubTree = this->_RecursivePostorderTraversal(node->right);
-	string currentNode = to_string(node->data);
-
-	string result = leftSubTree;
-	if (!leftSubTree.empty())
-	{
-		result += " ";
-	}
-	result += rightSubTree;
-	if (!rightSubTree.empty())
-	{
-		result += " ";
+		return;
 	}
-	result += currentNode;
-	return result;
+	this->_RecursivePostorderTraversal(node->left, result);
+	this->_RecursivePostorderTraversal(node->right, result);
+	result.push_back(node->data);
 }
 
-string BinarySearchTree::_MorrisInorderTraversal(Node* node)
+void BinarySearchTree::_MorrisInorderTraversal(Node* node, vector<int>& result)
 {
-	string result = "";
 	while (node != nullptr)
 	{
 		if (node->left == nullptr)
 		{
-			result += to_string(node->data) + " ";
+			result.push_back(node->data);
 			node = node->right;
 		}
 		else
@@ -261,26 +221,20 @@ string BinarySearchTree::_MorrisInorderTraversal(Node* node)
 			else
 			{
 				predecessor->right = nullptr;
-				result += to_string(node->data) + " ";
+				result.push_back(node->data);
 				node = node->right;
 			}
 		}
 	}
-	if (!result.empty())
-	{
-		result.pop_back();
-	}
-	return result;
 }
 
-string BinarySearchTree::_MorrisPreorderTraversal(Node* node)
+void BinarySearchTree::_MorrisPreorderTraversal(Node* node, vector<int> & result)
 {
-	string result = "";
 	while (node != nullptr)
 	{
 		if (node->left == nullptr)
 		{
-			result += to_string(node->data) + " ";
+			result.push_back(node->data);
 			node = node->right;
 		}
 		else
@@ -293,7 +247,7 @@ string BinarySearchTree::_MorrisPreorderTraversal(Node* node)
 			if (predecessor->right == nullptr)
 			{
 				predecessor->right = node;
-				result += to_string(node->data) + " ";
+				result.push_back(node->data);
 				node = node->left;
 			}
 			else
@@ -303,21 +257,15 @@ string BinarySearchTree::_MorrisPreorderTraversal(Node* node)
 			}
 		}
 	}
-	if (!result.empty())
-	{
-		result.pop_back();
-	}
-	return result;
 }
 
-string BinarySearchTree::_MorrisPostorderTraversal(Node* node)
+void BinarySearchTree::_MorrisPostorderTraversal(Node* node, vector<int>& result)
 {
-	string result = "";
 	while (node != nullptr)
 	{
 		if (node->right == nullptr)
 		{
-			result += to_string(node->data) + " ";
+			result.push_back(node->data);
 			node = node->left;
 		}
 		else
@@ -330,7 +278,7 @@ string BinarySearchTree::_MorrisPostorderTraversal(Node* node)
 			if (predecessor->left == nullptr)
 			{
 				predecessor->left = node;
-				result += to_string(node->data) + " ";
+				result.push_back(node->data);
 				node = node->right;
 			}
 			else
@@ -340,12 +288,7 @@ string BinarySearchTree::_MorrisPostorderTraversal(Node* node)
 			}
 		}
 	}
-	if (!result.empty())
-	{
-		result.pop_back();
-	}
 	reverse(result.begin(), result.end());
-	return result;
 }
 
 void BinarySearchTree::InsertNode(int value)
@@ -360,32 +303,44 @@ void BinarySearchTree::DeleteNode(int value)
 	this->_DeleteNode(node);
 }
 
-string BinarySearchTree::GetRecursiveInorderTravesalResult()
+vector<int> BinarySearchTree::GetRecursiveInorderTravesalResult()
 {
-	return this->_RecursiveInorderTraversal(this->_root);
+	vector<int> result;
+	this->_RecursiveInorderTraversal(this->_root, result);
+	return result;
 }
 
-string BinarySearchTree::GetRecursivePreorderTravesalResult()
+vector<int> BinarySearchTree::GetRecursivePreorderTravesalResult()
 {
-	return this->_RecursivePreorderTraversal(this->_root);
+	vector<int> result;
+	this->_RecursivePreorderTraversal(this->_root, result);
+	return result;
 }
 
-string BinarySearchTree::GetRecursivePostorderTravesalResult()
+vector<int> BinarySearchTree::GetRecursivePostorderTravesalResult()
 {
-	return this->_RecursivePostorderTraversal(this->_root);
+	vector<int> result;
+	this->_RecursivePostorderTraversal(this->_root, result);
+	return result;
 }
 
-string BinarySearchTree::GetMorrisInorderTraversalResult()
+vector<int> BinarySearchTree::GetMorrisInorderTraversalResult()
 {
-	return this->_MorrisInorderTraversal(this->_root);
+	vector<int> result;
+	this->_MorrisInorderTraversal(this->_root, result);
+	return result;
 }
 
-string BinarySearchTree::GetMorrisPreorderTraversalResult()
+vector<int> BinarySearchTree::GetMorrisPreorderTraversalResult()
 {
-	return this->_MorrisPreorderTraversal(this->_root);
+	vector<int> result;
+	this->_MorrisPreorderTraversal(this->_root, result);
+	return result;
 }
 
-string BinarySearchTree::GetMorrisPostorderTraversalResult()
+vector<int> BinarySearchTree::GetMorrisPostorderTraversalResult()
 {
-	return this->_MorrisPostorderTraversal(this->_root);
+	vector<int> result;
+	this->_MorrisPostorderTraversal(this->_root, result);
+	return result;
 }
diff --git a/Tests/0002_Tree/0001_BinarySearchTreeTest.cc b/Tests/0002_Tree/0001_BinarySearchTreeTest.cc
@@ -3,23 +3,22 @@
 #include "../Headers/0002_Tree/0001_BinarySearchTree.h"
 #include "../0000_CommonUtilities/UnitTestHelper.h"
 
-// Demonstrate some basic assertions.
 namespace BinarySearchTreeTest
 {
+    UnitTestHelper<int> unitTestHelper;
+
     TEST(BSTInsertData, RecursiveInorderTest)
     {
-        UnitTestHelper<int> unitTestHelper;
         BinarySearchTree bst;
         bst.InsertNode(50);
         bst.InsertNode(30);
         bst.InsertNode(60);
 
 
-        string actualResult = bst.GetRecursiveInorderTravesalResult();
-        string r = unitTestHelper.VerifyVectorResult({30, 50, 60});
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetRecursiveInorderTravesalResult());
         string expectedResult = "30 50 60";
 
-        EXPECT_EQ(actualResult, r);
+        EXPECT_EQ(actualResult, expectedResult);
     }
 
     TEST(BSTInsertData, RecursivePreorderTest)
@@ -29,7 +28,7 @@ namespace BinarySearchTreeTest
         bst.InsertNode(30);
         bst.InsertNode(60);
 
-        string actualResult = bst.GetRecursivePreorderTravesalResult();
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetRecursivePreorderTravesalResult());
         string expectedResult = "50 30 60";
 
         EXPECT_EQ(actualResult, expectedResult);
@@ -42,7 +41,7 @@ namespace BinarySearchTreeTest
         bst.InsertNode(30);
         bst.InsertNode(60);
 
-        string actualResult = bst.GetRecursivePostorderTravesalResult();
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetRecursivePostorderTravesalResult());
         string expectedResult = "30 60 50";
 
         EXPECT_EQ(actualResult, expectedResult);
@@ -56,7 +55,7 @@ namespace BinarySearchTreeTest
         bst.InsertNode(60);
         
 
-        string actualResult = bst.GetMorrisInorderTraversalResult();
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetMorrisInorderTraversalResult());
         string expectedResult = "30 50 60";
 
         EXPECT_EQ(actualResult, expectedResult);
@@ -70,7 +69,7 @@ namespace BinarySearchTreeTest
         bst.InsertNode(60);
 
 
-        string actualResult = bst.GetMorrisPreorderTraversalResult();
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetMorrisPreorderTraversalResult());
         string expectedResult = "50 30 60";
 
         EXPECT_EQ(actualResult, expectedResult);
@@ -84,7 +83,7 @@ namespace BinarySearchTreeTest
         bst.InsertNode(60);
 
 
-        string actualResult = bst.GetMorrisPostorderTraversalResult();
+        string actualResult = unitTestHelper.VerifyVectorResult(bst.GetMorrisPostorderTraversalResult());
         string expectedResult = "30 60 50";
 
         EXPECT_EQ(actualResult, expectedResult);

Original file line number	Diff line number	Diff line change
`@@ -164,86 +164,46 @@ void BinarySearchTree::_DeleteNode(Node* node)`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`
`167`		`-string BinarySearchTree::_RecursiveInorderTraversal(Node* node)`
	`167`	`+void BinarySearchTree::_RecursiveInorderTraversal(Node* node, vector<int>& result)`
`168`	`168`	`{`
`169`	`169`	`if (node == nullptr)`
`170`	`170`	`{`
`171`		`- return "";`
	`171`	`+ return;`
`172`	`172`	`}`
`173`		`- string leftSubTree = this->_RecursiveInorderTraversal(node->left);`
`174`		`- string currentNode = to_string(node->data);`
`175`		`- string rightSubTree = this->_RecursiveInorderTraversal(node->right);`
`176`		`-`
`177`		`- string result = leftSubTree;`
`178`		`- if (!leftSubTree.empty())`
`179`		`- {`
`180`		`- result += " ";`
`181`		`- }`
`182`		`- result += currentNode;`
`183`		`- if (!rightSubTree.empty())`
`184`		`- {`
`185`		`- result += " ";`
`186`		`- }`
`187`		`- result += rightSubTree;`
`188`		`- return result;`
	`173`	`+ this->_RecursiveInorderTraversal(node->left, result);`
	`174`	`+ result.push_back(node->data);`
	`175`	`+ this->_RecursiveInorderTraversal(node->right, result);`
`189`	`176`	`}`
`190`	`177`
`191`		`-string BinarySearchTree::_RecursivePreorderTraversal(Node* node)`
	`178`	`+void BinarySearchTree::_RecursivePreorderTraversal(Node* node, vector<int>& result)`
`192`	`179`	`{`
`193`	`180`	`if (node == nullptr)`
`194`	`181`	`{`
`195`		`- return "";`
`196`		`- }`
`197`		`- string currentNode = to_string(node->data);`
`198`		`- string leftSubTree = this->_RecursivePreorderTraversal(node->left);`
`199`		`- string rightSubTree = this->_RecursivePreorderTraversal(node->right);`
`200`		`-`
`201`		`- string result = currentNode;`
`202`		`- if (!leftSubTree.empty())`
`203`		`- {`
`204`		`- result += " ";`
	`182`	`+ return;`
`205`	`183`	`}`
`206`		`- result += leftSubTree;`
`207`		`- if (!rightSubTree.empty())`
`208`		`- {`
`209`		`- result += " ";`
`210`		`- }`
`211`		`- result += rightSubTree;`
`212`		`- return result;`
	`184`	`+ result.push_back(node->data);`
	`185`	`+ this->_RecursivePreorderTraversal(node->left, result);`
	`186`	`+ this->_RecursivePreorderTraversal(node->right, result);`
`213`	`187`	`}`
`214`	`188`
`215`		`-string BinarySearchTree::_RecursivePostorderTraversal(Node* node)`
	`189`	`+void BinarySearchTree::_RecursivePostorderTraversal(Node* node, vector<int>& result)`
`216`	`190`	`{`
`217`	`191`	`if (node == nullptr)`
`218`	`192`	`{`
`219`		`- return "";`
`220`		`- }`
`221`		`- string leftSubTree = this->_RecursivePostorderTraversal(node->left);`
`222`		`- string rightSubTree = this->_RecursivePostorderTraversal(node->right);`
`223`		`- string currentNode = to_string(node->data);`
`224`		`-`
`225`		`- string result = leftSubTree;`
`226`		`- if (!leftSubTree.empty())`
`227`		`- {`
`228`		`- result += " ";`
`229`		`- }`
`230`		`- result += rightSubTree;`
`231`		`- if (!rightSubTree.empty())`
`232`		`- {`
`233`		`- result += " ";`
	`193`	`+ return;`
`234`	`194`	`}`
`235`		`- result += currentNode;`
`236`		`- return result;`
	`195`	`+ this->_RecursivePostorderTraversal(node->left, result);`
	`196`	`+ this->_RecursivePostorderTraversal(node->right, result);`
	`197`	`+ result.push_back(node->data);`
`237`	`198`	`}`
`238`	`199`
`239`		`-string BinarySearchTree::_MorrisInorderTraversal(Node* node)`
	`200`	`+void BinarySearchTree::_MorrisInorderTraversal(Node* node, vector<int>& result)`
`240`	`201`	`{`
`241`		`- string result = "";`
`242`	`202`	`while (node != nullptr)`
`243`	`203`	`{`
`244`	`204`	`if (node->left == nullptr)`
`245`	`205`	`{`
`246`		`- result += to_string(node->data) + " ";`
	`206`	`+ result.push_back(node->data);`
`247`	`207`	`node = node->right;`
`248`	`208`	`}`
`249`	`209`	`else`
`@@ -261,26 +221,20 @@ string BinarySearchTree::_MorrisInorderTraversal(Node* node)`
`261`	`221`	`else`
`262`	`222`	`{`
`263`	`223`	`predecessor->right = nullptr;`
`264`		`- result += to_string(node->data) + " ";`
	`224`	`+ result.push_back(node->data);`
`265`	`225`	`node = node->right;`
`266`	`226`	`}`
`267`	`227`	`}`
`268`	`228`	`}`
`269`		`- if (!result.empty())`
`270`		`- {`
`271`		`- result.pop_back();`
`272`		`- }`
`273`		`- return result;`
`274`	`229`	`}`
`275`	`230`
`276`		`-string BinarySearchTree::_MorrisPreorderTraversal(Node* node)`
	`231`	`+void BinarySearchTree::_MorrisPreorderTraversal(Node* node, vector<int> & result)`
`277`	`232`	`{`
`278`		`- string result = "";`
`279`	`233`	`while (node != nullptr)`
`280`	`234`	`{`
`281`	`235`	`if (node->left == nullptr)`
`282`	`236`	`{`
`283`		`- result += to_string(node->data) + " ";`
	`237`	`+ result.push_back(node->data);`
`284`	`238`	`node = node->right;`
`285`	`239`	`}`
`286`	`240`	`else`
`@@ -293,7 +247,7 @@ string BinarySearchTree::_MorrisPreorderTraversal(Node* node)`
`293`	`247`	`if (predecessor->right == nullptr)`
`294`	`248`	`{`
`295`	`249`	`predecessor->right = node;`
`296`		`- result += to_string(node->data) + " ";`
	`250`	`+ result.push_back(node->data);`
`297`	`251`	`node = node->left;`
`298`	`252`	`}`
`299`	`253`	`else`
`@@ -303,21 +257,15 @@ string BinarySearchTree::_MorrisPreorderTraversal(Node* node)`
`303`	`257`	`}`
`304`	`258`	`}`
`305`	`259`	`}`
`306`		`- if (!result.empty())`
`307`		`- {`
`308`		`- result.pop_back();`
`309`		`- }`
`310`		`- return result;`
`311`	`260`	`}`
`312`	`261`
`313`		`-string BinarySearchTree::_MorrisPostorderTraversal(Node* node)`
	`262`	`+void BinarySearchTree::_MorrisPostorderTraversal(Node* node, vector<int>& result)`
`314`	`263`	`{`
`315`		`- string result = "";`
`316`	`264`	`while (node != nullptr)`
`317`	`265`	`{`
`318`	`266`	`if (node->right == nullptr)`
`319`	`267`	`{`
`320`		`- result += to_string(node->data) + " ";`
	`268`	`+ result.push_back(node->data);`
`321`	`269`	`node = node->left;`
`322`	`270`	`}`
`323`	`271`	`else`
`@@ -330,7 +278,7 @@ string BinarySearchTree::_MorrisPostorderTraversal(Node* node)`
`330`	`278`	`if (predecessor->left == nullptr)`
`331`	`279`	`{`
`332`	`280`	`predecessor->left = node;`
`333`		`- result += to_string(node->data) + " ";`
	`281`	`+ result.push_back(node->data);`
`334`	`282`	`node = node->right;`
`335`	`283`	`}`
`336`	`284`	`else`
`@@ -340,12 +288,7 @@ string BinarySearchTree::_MorrisPostorderTraversal(Node* node)`
`340`	`288`	`}`
`341`	`289`	`}`
`342`	`290`	`}`
`343`		`- if (!result.empty())`
`344`		`- {`
`345`		`- result.pop_back();`
`346`		`- }`
`347`	`291`	`reverse(result.begin(), result.end());`
`348`		`- return result;`
`349`	`292`	`}`
`350`	`293`
`351`	`294`	`void BinarySearchTree::InsertNode(int value)`
`@@ -360,32 +303,44 @@ void BinarySearchTree::DeleteNode(int value)`
`360`	`303`	`this->_DeleteNode(node);`
`361`	`304`	`}`
`362`	`305`
`363`		`-string BinarySearchTree::GetRecursiveInorderTravesalResult()`
	`306`	`+vector<int> BinarySearchTree::GetRecursiveInorderTravesalResult()`
`364`	`307`	`{`
`365`		`- return this->_RecursiveInorderTraversal(this->_root);`
	`308`	`+ vector<int> result;`
	`309`	`+ this->_RecursiveInorderTraversal(this->_root, result);`
	`310`	`+ return result;`
`366`	`311`	`}`
`367`	`312`
`368`		`-string BinarySearchTree::GetRecursivePreorderTravesalResult()`
	`313`	`+vector<int> BinarySearchTree::GetRecursivePreorderTravesalResult()`
`369`	`314`	`{`
`370`		`- return this->_RecursivePreorderTraversal(this->_root);`
	`315`	`+ vector<int> result;`
	`316`	`+ this->_RecursivePreorderTraversal(this->_root, result);`
	`317`	`+ return result;`
`371`	`318`	`}`
`372`	`319`
`373`		`-string BinarySearchTree::GetRecursivePostorderTravesalResult()`
	`320`	`+vector<int> BinarySearchTree::GetRecursivePostorderTravesalResult()`
`374`	`321`	`{`
`375`		`- return this->_RecursivePostorderTraversal(this->_root);`
	`322`	`+ vector<int> result;`
	`323`	`+ this->_RecursivePostorderTraversal(this->_root, result);`
	`324`	`+ return result;`
`376`	`325`	`}`
`377`	`326`
`378`		`-string BinarySearchTree::GetMorrisInorderTraversalResult()`
	`327`	`+vector<int> BinarySearchTree::GetMorrisInorderTraversalResult()`
`379`	`328`	`{`
`380`		`- return this->_MorrisInorderTraversal(this->_root);`
	`329`	`+ vector<int> result;`
	`330`	`+ this->_MorrisInorderTraversal(this->_root, result);`
	`331`	`+ return result;`
`381`	`332`	`}`
`382`	`333`
`383`		`-string BinarySearchTree::GetMorrisPreorderTraversalResult()`
	`334`	`+vector<int> BinarySearchTree::GetMorrisPreorderTraversalResult()`
`384`	`335`	`{`
`385`		`- return this->_MorrisPreorderTraversal(this->_root);`
	`336`	`+ vector<int> result;`
	`337`	`+ this->_MorrisPreorderTraversal(this->_root, result);`
	`338`	`+ return result;`
`386`	`339`	`}`
`387`	`340`
`388`		`-string BinarySearchTree::GetMorrisPostorderTraversalResult()`
	`341`	`+vector<int> BinarySearchTree::GetMorrisPostorderTraversalResult()`
`389`	`342`	`{`
`390`		`- return this->_MorrisPostorderTraversal(this->_root);`
	`343`	`+ vector<int> result;`
	`344`	`+ this->_MorrisPostorderTraversal(this->_root, result);`
	`345`	`+ return result;`
`391`	`346`	`}`