Binary tree impl

binary-trees/binarytree.hpp

@@ -12,10 +12,16 @@ namespace BinaryTree
 	std::unique_ptr<Node<T>> left;
 	std::unique_ptr<Node<T>> right;
 
+	bool IsLeaf() const
+	{
+		return left == nullptr && right == nullptr;
+	}
+
 	Node(T const &_value, Node<T> *_parent)
 			: parent(_parent),
 				value(_value)
-        {}
+	{
+	}
 };
 
 template <class T>
@@ -24,52 +30,102 @@ namespace BinaryTree
 private:
 	std::unique_ptr<Node<T>> root;
 
+	std::unique_ptr<Node<T>> & GetRightMostLeaf(std::unique_ptr<Node<T>> &localRoot)
+	{
+		std::unique_ptr<Node<T>> *nodePtr = &localRoot;
+		while ((*nodePtr)->right != nullptr)
+		{
+			nodePtr = &((*nodePtr)->right);
+		}
+
+		return *nodePtr;
+	}
+
 public:
-        void Insert(T & value)
+	void Insert(T value)
 	{
 		Node<T> *previousPtr = nullptr;
-            std::unique_ptr<Node<T>> & ptr = root;
+		std::unique_ptr<Node<T>> *rootPtr = &root;
-            while(ptr != nullptr)
+		while (*rootPtr != nullptr)
 		{
-                previousPtr = ptr.get();
+			previousPtr = rootPtr->get();
-                if(ptr->value > value)
+			if ((*rootPtr)->value > value)
 			{
-                    ptr = ptr->left;
+				rootPtr = &((*rootPtr)->left);
 			}
 			else
 			{
-                    ptr = ptr->right;
+				rootPtr = &((*rootPtr)->right);
 			}
 		}
-            ptr = std::make_unique<Node<T>>(value, previousPtr);
+		*rootPtr = std::make_unique<Node<T>>(value, previousPtr);
 	}
 
-        bool Contains(T const & value)
+	bool Contains(T const value)
 	{
-            std::unique_ptr<Node<T>> & ptr = root;
+		std::unique_ptr<Node<T>> *rootPtr = &root;
-            while(ptr != nullptr)
+		while (*rootPtr != nullptr)
 		{
-                if(ptr->value == value)
+			if ((*rootPtr)->value == value)
 			{
 				return true;
 			}
 
-                if(ptr->value > value)
+			if ((*rootPtr)->value > value)
 			{
-                    ptr = ptr->left;
+				rootPtr = &((*rootPtr)->left);
 			}
 			else
 			{
-                    ptr = ptr->right;
+				rootPtr = &((*rootPtr)->right);
 			}
 		}
 
 		return false;
 	}
 
-        void Delete(T const & value)
+	void Delete(T const value)
 	{
+		std::unique_ptr<Node<T>> *rootPtr = &root;
+		while (*rootPtr != nullptr)
+		{
+			if ((*rootPtr)->value == value)
+			{
+				if ((*rootPtr)->IsLeaf())
+				{
+					rootPtr->release();
+					return;
+				}
 
+				if ((*rootPtr)->left == nullptr)
+				{
+					rootPtr->swap((*rootPtr)->right);
+					(*rootPtr)->right.release();
+				}
+				else if ((*rootPtr)->right == nullptr)
+				{
+					rootPtr->swap((*rootPtr)->left);
+					(*rootPtr)->left.release();
+				}
+				else
+				{
+					auto &replacementNode = GetRightMostLeaf((*rootPtr)->left);
+					rootPtr->swap(replacementNode);
+					replacementNode.release();
+				}
+
+				return;
+			}
+
+			if ((*rootPtr)->value > value)
+			{
+				rootPtr = &((*rootPtr)->left);
+			}
+			else
+			{
+				rootPtr = &((*rootPtr)->right);
+			}
+		}
 	}
 };
-}
+} // namespace BinaryTree