Fix PR suggestions, add more test for case when node without children is removed, fix condition when removing last node.

Author: PatrykOlejniczak

DataStructures/Trees/RedBlackTree.cs

@@ -13,7 +13,6 @@ public enum RedBlackTreeColors
         Black = 1
     };
 
-
     /// <summary>
     /// Red-Black Tree Data Structure.
     /// </summary>
@@ -28,6 +27,10 @@ public class RedBlackTree<TKey> : BinarySearchTree<TKey> where TKey : IComparabl
             internal set { base.Root = value; }
         }
 
+        private bool IsRoot(RedBlackTreeNode<TKey> node)
+        {
+            return node == this.Root;
+        }
 
         /// <summary>
         /// CONSTRUCTOR.
@@ -465,16 +468,21 @@ protected bool _remove(RedBlackTreeNode<TKey> nodeToDelete)
                 return false;
             }
 
-            if (!nodeToDelete.HasChildren)
+            if (IsRoot(nodeToDelete) && !nodeToDelete.HasChildren)
             {
                 Root = null;
             }
             else
             {
-                // X it's node that will become move to original nodeToDelete position in the tree.
+                // X is the node we will replace with the nodeToDelete in the tree once we remove it.
                 RedBlackTreeNode<TKey> x;
 
-                if (nodeToDelete.HasOnlyRightChild)
+                if (!nodeToDelete.HasChildren)
+                {
+                    x = nodeToDelete;
+                    Transplant(nodeToDelete, null);
+                }
+                else if (nodeToDelete.HasOnlyRightChild)
                 {
                     x = nodeToDelete.RightChild;
                     Transplant(nodeToDelete, nodeToDelete.RightChild);
@@ -486,8 +494,8 @@ protected bool _remove(RedBlackTreeNode<TKey> nodeToDelete)
                 }
                 else
                 {
-                    // Y it's node that will become move to original X position in the tree.
-                    var y = (RedBlackTreeNode<TKey>) _findMinNode(nodeToDelete.RightChild);
+                    // Y is the node we will replace with the X in the tree once we move it to the nodeToDelete position.
+                    var y = (RedBlackTreeNode<TKey>)_findMinNode(nodeToDelete.RightChild);
                     x = y.RightChild;
 
                     if (y.Parent == nodeToDelete)
@@ -652,7 +660,5 @@ public override void RemoveMax()
             // Invoke the internal remove node method.
             this._remove(node);
         }
-
     }
-
 }

UnitTest/DataStructuresTests/RedBlackTreeTest.cs

@@ -375,6 +375,47 @@ public void Remove_ThrowExceptionWhenTryRemoveNonExistentNode()
             Assert.Throws<Exception>(() =>redBlackTree.Remove(999));
         }
 
+        /** Remove 8, (r -> red, b -> black):
+         **          11(b)             ===>        11(b)
+         **         /    \             ===>       /     \
+         **      (r)3    13(b)         ===>    (r)3     13(b)
+         **       / \      \           ===>     / \      \
+         **   (b)1  7(b)   15(r)       ===> (b)1  7(b)   15(r)
+         **         / \                ===>       /
+         **     (r)5   8(r)            ===>     5(r)
+         **/
+        [Fact]
+        public void Remove_NodeWithoutChildren()
+        {
+            redBlackTree.Remove(8);
+
+            RedBlackTreeRule.CheckRedBlackTreeRules(redBlackTree);
+
+            Assert.Equal(7, redBlackTree.Count);
+            Assert.Equal(11, redBlackTree.Root.Value);
+            Assert.Equal(RedBlackTreeColors.Black, redBlackTree.Root.Color);
+
+            Assert.Equal(3, redBlackTree.Root.LeftChild.Value);
+            Assert.Equal(RedBlackTreeColors.Red, redBlackTree.Root.LeftChild.Color);
+
+            Assert.Equal(1, redBlackTree.Root.LeftChild.LeftChild.Value);
+            Assert.Equal(RedBlackTreeColors.Black, redBlackTree.Root.LeftChild.LeftChild.Color);
+
+            Assert.Equal(7, redBlackTree.Root.LeftChild.RightChild.Value);
+            Assert.Equal(RedBlackTreeColors.Black, redBlackTree.Root.LeftChild.RightChild.Color);
+
+            Assert.Equal(5, redBlackTree.Root.LeftChild.RightChild.LeftChild.Value);
+            Assert.Equal(RedBlackTreeColors.Red, redBlackTree.Root.LeftChild.RightChild.LeftChild.Color);
+
+            Assert.Null(redBlackTree.Root.LeftChild.RightChild.RightChild);
+
+            Assert.Equal(13, redBlackTree.Root.RightChild.Value);
+            Assert.Equal(RedBlackTreeColors.Black, redBlackTree.Root.RightChild.Color);
+
+            Assert.Equal(15, redBlackTree.Root.RightChild.RightChild.Value);
+            Assert.Equal(RedBlackTreeColors.Red, redBlackTree.Root.RightChild.RightChild.Color);
+        }
+
         [Fact]
         public void Remove_OneAndOnlyTreeNode()
         {