Testing and fixing of: BinarySearchTreeMap and RedBlackTreeMap.

aalhour · aalhour · commit 43d0acb7c7e1 · 2016-04-17T14:28:49.000+02:00
diff --git a/DataStructures/Trees/BinarySearchTreeMap.cs b/DataStructures/Trees/BinarySearchTreeMap.cs
@@ -468,7 +468,7 @@ public virtual void Update(TKey key, TValue newValue)
             var node = _findNode(Root, key);
 
             if (node == null)
-                throw new KeyNotFoundException();
+                throw new KeyNotFoundException("Key doesn't exist in tree.");
 
             node.Value = newValue;
         }
@@ -482,11 +482,11 @@ public virtual void Remove(TKey key)
                 throw new Exception("Tree is empty.");
 
             var node = _findNode(Root, key);
-            bool status = _remove(node);
 
-            // If the element was found, remove it.
-            if (status == false)
-                throw new Exception("Item was not found.");
+            if (node == null)
+                throw new KeyNotFoundException("Key doesn't exist in tree.");
+            
+            _remove(node);
         }
 
         /// <summary>
@@ -599,7 +599,7 @@ public virtual KeyValuePair<TKey, TValue> Find(TKey key)
             if (node != null)
                 return new KeyValuePair<TKey, TValue>(node.Key, node.Value);
             else
-                throw new Exception("Item was not found.");
+                throw new KeyNotFoundException("Item was not found.");
         }
 
         /// <summary>
diff --git a/DataStructures/Trees/BinarySearchTreeMapNode.cs b/DataStructures/Trees/BinarySearchTreeMapNode.cs
@@ -13,11 +13,7 @@ public class BSTMapNode<TKey, TValue> : IComparable<BSTMapNode<TKey, TValue>> wh
         private BSTMapNode<TKey, TValue> _left;
         private BSTMapNode<TKey, TValue> _right;
 
-        public BSTMapNode()
-        {
-            throw new NotSupportedException();
-        }
-
+        public BSTMapNode() { }
         public BSTMapNode(TKey key) : this(key, default(TValue), 0, null, null, null) { }
         public BSTMapNode(TKey key, TValue value) : this(key, value, 0, null, null, null) { }
         public BSTMapNode(TKey key, TValue value, int subTreeSize, BSTMapNode<TKey, TValue> parent, BSTMapNode<TKey, TValue> left, BSTMapNode<TKey, TValue> right)
diff --git a/DataStructures/Trees/IBinarySearchTree.cs b/DataStructures/Trees/IBinarySearchTree.cs
@@ -78,6 +78,7 @@ public interface IBinarySearchTree<T> where T : System.IComparable<T>
     /// <typeparam name="TValue">Type of records per node.</typeparam>
     public interface IBinarySearchTree<TKey, TValue> where TKey : System.IComparable<TKey>
     {
+        BSTMapNode<TKey, TValue> Root { get; }
         int Count { get; }
         bool IsEmpty { get; }
         int Height { get; }
diff --git a/DataStructures/Trees/RedBlackTreeMapNode.cs b/DataStructures/Trees/RedBlackTreeMapNode.cs
@@ -15,7 +15,7 @@ public RedBlackTreeMapNode(TKey key, TValue value) : this(key, value, 0, null, n
         public RedBlackTreeMapNode(TKey key, TValue value, int height, RedBlackTreeMapNode<TKey, TValue> parent, RedBlackTreeMapNode<TKey, TValue> left, RedBlackTreeMapNode<TKey, TValue> right)
         {
             Key = key;
-            Value = Value;
+            Value = value;
             Color = RedBlackTreeColors.Red;
             Parent = parent;
             LeftChild = left;
diff --git a/DataStructures/Trees/TreeDrawer.cs b/DataStructures/Trees/TreeDrawer.cs
@@ -20,6 +20,12 @@ public static string DrawTree<T>(this IBinarySearchTree<T> tree) where T : IComp
             return String.Join("\n", _recursivelyDrawTree(tree.Root, out position, out width));
         }
 
+        public static string DrawTree<TKey, TValue>(this IBinarySearchTree<TKey, TValue> tree, bool includeValues = false) where TKey : IComparable<TKey>
+        {
+            int position, width;
+            return String.Join("\n", _recursivelyDrawTree(tree.Root, out position, out width, includeValues));
+        }
+
 
         /// <summary>
         /// /// Recusively draws the tree starting from node.
@@ -36,7 +42,9 @@ public static string DrawTree<T>(this IBinarySearchTree<T> tree) where T : IComp
         /// <param name="positionOutput"></param>
         /// <param name="widthOutput"></param>
         /// <returns>List of tree levels as strings.</returns>
-        private static List<string> _recursivelyDrawTree<T>(BSTNode<T> node, out int positionOutput, out int widthOutput) where T : IComparable<T>
+        private static List<string> _recursivelyDrawTree<T>
+            (BSTNode<T> node, out int positionOutput, out int widthOutput) 
+            where T : IComparable<T>
         {
             widthOutput = 0;
             positionOutput = 0;
@@ -121,5 +129,104 @@ private static List<string> _recursivelyDrawTree<T>(BSTNode<T> node, out int pos
             positionOutput = position_out;
             return listOfLines;
         }
+
+
+        private static List<string> _recursivelyDrawTree<TKey, TValue>
+            (BSTMapNode<TKey, TValue> node, out int positionOutput, out int widthOutput, bool includeValues = false)
+            where TKey : IComparable<TKey>
+        {
+            widthOutput = 0;
+            positionOutput = 0;
+            List<string> listOfLines = new List<string>();
+
+            if (node == null)
+            {
+                return listOfLines;
+            }
+
+            //
+            // Variables
+            string nodeLabel = "";
+            int padValue = 0;
+
+            List<string> leftLines, rightLines;
+            leftLines = rightLines = new List<string>();
+
+            int leftPosition = 0, rightPosition = 0;
+            int leftWidth = 0, rightWidth = 0;
+            int middle, position_out, width_out;
+
+            //
+            // Start drawing
+            if (includeValues == true)
+            {
+                nodeLabel = String.Format("<{0}: {1}>", Convert.ToString(node.Key), Convert.ToString(node.Value));
+                padValue = 4;
+            }
+            else
+            {
+                nodeLabel = Convert.ToString(node.Key);
+                padValue = 2;
+            }
+
+            // Visit the left child
+            leftLines = _recursivelyDrawTree(node.LeftChild, out leftPosition, out leftWidth, includeValues);
+
+            // Visit the right child
+            rightLines = _recursivelyDrawTree(node.RightChild, out rightPosition, out rightWidth, includeValues);
+
+            // Calculate pads
+            middle = Math.Max(Math.Max(padValue, nodeLabel.Length), (rightPosition + leftWidth - leftPosition + 1));
+            position_out = leftPosition + middle;
+            width_out = leftPosition + middle + rightWidth - rightPosition;
+
+            while (leftLines.Count < rightLines.Count)
+                leftLines.Add(new String(' ', leftWidth));
+
+            while (rightLines.Count < leftLines.Count)
+                rightLines.Add(new String(' ', rightWidth));
+
+            if ((middle - nodeLabel.Length % padValue == 1) && (nodeLabel.Length < middle) && (node.Parent != null && node.IsLeftChild))
+                nodeLabel += ".";
+
+            // Format the node's label
+            nodeLabel = nodeLabel.PadCenter(middle, '.');
+
+            var nodeLabelChars = nodeLabel.ToCharArray();
+
+            if (nodeLabelChars[0] == '.')
+                nodeLabelChars[0] = ' ';
+
+            if (nodeLabelChars[nodeLabelChars.Length - 1] == '.')
+                nodeLabelChars[nodeLabelChars.Length - 1] = ' ';
+
+            nodeLabel = String.Join("", nodeLabelChars);
+
+            //
+            // Construct the list of lines.
+            listOfLines = new List<string>()
+                {
+                    // 0
+                    (new String(' ', leftPosition )) + nodeLabel + (new String(' ', (rightWidth - rightPosition))),
+
+                    // 1
+                    (new String(' ', leftPosition)) + "/" + (new String(' ', (middle - padValue))) + "\\" + (new String(' ', (rightWidth - rightPosition))) 
+                };
+
+            //
+            // Add the right lines and left lines to the final list of lines.
+            listOfLines =
+                listOfLines.Concat(
+                    leftLines.Zip(
+                        rightLines, (left_line, right_line) =>
+                        left_line + (new String(' ', (width_out - leftWidth - rightWidth))) + right_line)
+                ).ToList();
+
+            //
+            // Return
+            widthOutput = width_out;
+            positionOutput = position_out;
+            return listOfLines;
+        }
     }
 }
diff --git a/MainProgram/DataStructuresTests/BinarySearchTreeMapTests.cs b/MainProgram/DataStructuresTests/BinarySearchTreeMapTests.cs
@@ -0,0 +1,184 @@
+﻿using System;
+using System.Diagnostics;
+using System.Collections.Generic;
+
+using DataStructures.Common;
+using DataStructures.Trees;
+
+namespace C_Sharp_Algorithms.DataStructuresTests
+{
+    public static class BinarySearchTreeMapTests
+    {
+        public static void DoTest()
+        {
+            // Binary Search Tree Map collection
+            var bstMap = new BinarySearchTreeMap<int, string>(allowDuplicates: false);
+
+            // Testing data
+            KeyValuePair<int, string>[] values = new KeyValuePair<int, string>[10];
+
+            // Prepare the values array
+            for(int i = 1; i <= 10; ++i)
+            {
+                var keyValPair = new KeyValuePair<int, string>(i, String.Format("Integer: {0}", i));
+                values[i - 1] = keyValPair;
+            }
+
+
+            //
+            // Test singular insert
+            for (int i = 0; i < 10; ++i)
+                bstMap.Insert(values[i].Key, values[i].Value);
+
+            Debug.Assert(bstMap.Count == values.Length, "Expected the same number of items.");
+
+            bstMap.Clear();
+
+
+            //
+            // Test collection insert
+            bstMap.Insert(values);
+
+
+            //
+            // Test enumeration of key-value pairs is still in oreder
+            var enumerator = bstMap.GetInOrderEnumerator();
+            for (int i = 0; i < 10; ++i)
+            {
+                if (enumerator.MoveNext())
+                {
+                    var curr = enumerator.Current;
+                    if (curr.Key != values[i].Key || curr.Value != values[i].Value)
+                        throw new Exception();
+                }
+            }
+
+
+            //
+            // Test against re-shuffled insertions (not like above order)
+            bstMap = new BinarySearchTreeMap<int, string>(allowDuplicates: false);
+
+            bstMap.Insert(4, "int4");
+            bstMap.Insert(5, "int5");
+            bstMap.Insert(7, "int7");
+            bstMap.Insert(2, "int2");
+            bstMap.Insert(1, "int1");
+            bstMap.Insert(3, "int3");
+            bstMap.Insert(6, "int6");
+            bstMap.Insert(0, "int0");
+            bstMap.Insert(8, "int8");
+            bstMap.Insert(10, "int10");
+            bstMap.Insert(9, "int9");
+
+            Debug.Assert(bstMap.Count == values.Length, "Expected the same number of items.");
+
+
+            //
+            // ASSERT INSERTING DUPLICATES WOULD BREAK
+            var insert_duplicate_passed = true;
+            try
+            {
+                // 2 already exists in tree
+                bstMap.Insert(2, "int2");
+                insert_duplicate_passed = true;
+            }
+            catch
+            {
+                insert_duplicate_passed = false;
+            }
+
+            Debug.Assert(insert_duplicate_passed == false, "Fail! The tree doesn't allow duplicates");
+
+
+            //
+            // Test find
+            Debug.Assert(bstMap.Find(5).Key == 5, "Wrong find result!");
+            Debug.Assert(bstMap.FindMin().Key == 0, "Wrong min!");
+            Debug.Assert(bstMap.FindMax().Key == 10, "Wrong max!");
+
+
+            //
+            // Assert find raises exception on non-existing elements
+            bool threwKeyNotFoundError = false;
+
+            try
+            {
+                bstMap.Find(999999999);
+                threwKeyNotFoundError = false;
+            }
+            catch(KeyNotFoundException)
+            {
+                threwKeyNotFoundError = true;
+            }
+
+            Debug.Assert(true == threwKeyNotFoundError, "Expected to catch KeyNotFoundException.");
+
+
+            //
+            // PRINT TREE
+            Console.WriteLine("*****************************");
+            Console.WriteLine(" [*] BINARY SEARCH TREE TREE:\r\n");
+            Console.WriteLine("*****************************");
+            Console.WriteLine(bstMap.DrawTree());
+            Console.WriteLine("\r\n");
+
+
+            //
+            // Assert count
+            Debug.Assert(bstMap.Count == 11);
+
+
+            //
+            // Assert existence and nonexistence of some items
+            Debug.Assert(bstMap.Contains(1) == true);
+            Debug.Assert(bstMap.Contains(3) == true);
+            Debug.Assert(bstMap.Contains(999) == false);
+
+
+            //
+            // Do some deletions
+            bstMap.Remove(7);
+            bstMap.Remove(1);
+            bstMap.Remove(3);
+
+
+            //
+            // Assert count
+            Debug.Assert(bstMap.Count == 8);
+
+
+            //
+            // Assert nonexistence of previously existing items
+            Debug.Assert(bstMap.Contains(1) == false);
+            Debug.Assert(bstMap.Contains(3) == false);
+
+
+            //
+            // Remove root key
+            var oldRootKey = bstMap.Root.Key;
+            bstMap.Remove(bstMap.Root.Key);
+
+
+            //
+            // Assert count
+            Debug.Assert(bstMap.Count == 7);
+
+
+            //
+            // Assert nonexistence of old root's key
+            Debug.Assert(bstMap.Contains(oldRootKey) == false);
+
+
+            //
+            // PRINT TREE
+            Console.WriteLine("*****************************");
+            Console.WriteLine(" [*] BINARY SEARCH TREE TREE:\r\n");
+            Console.WriteLine("*****************************");
+            Console.WriteLine(bstMap.DrawTree(includeValues: true));
+            Console.WriteLine("\r\n");
+
+            Console.ReadLine();
+        }//end-do-test
+    }
+}
+
diff --git a/MainProgram/DataStructuresTests/RedBlackTreeMapTests.cs b/MainProgram/DataStructuresTests/RedBlackTreeMapTests.cs
diff --git a/MainProgram/MainProgram.csproj b/MainProgram/MainProgram.csproj
diff --git a/MainProgram/Program.cs b/MainProgram/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,7 @@ public interface IBinarySearchTree<T> where T : System.IComparable<T>`
`78`	`78`	`/// <typeparam name="TValue">Type of records per node.</typeparam>`
`79`	`79`	`public interface IBinarySearchTree<TKey, TValue> where TKey : System.IComparable<TKey>`
`80`	`80`	`{`
	`81`	`+ BSTMapNode<TKey, TValue> Root { get; }`
`81`	`82`	`int Count { get; }`
`82`	`83`	`bool IsEmpty { get; }`
`83`	`84`	`int Height { get; }`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public RedBlackTreeMapNode(TKey key, TValue value) : this(key, value, 0, null, n`
`15`	`15`	`public RedBlackTreeMapNode(TKey key, TValue value, int height, RedBlackTreeMapNode<TKey, TValue> parent, RedBlackTreeMapNode<TKey, TValue> left, RedBlackTreeMapNode<TKey, TValue> right)`
`16`	`16`	`{`
`17`	`17`	`Key = key;`
`18`		`- Value = Value;`
	`18`	`+ Value = value;`
`19`	`19`	`Color = RedBlackTreeColors.Red;`
`20`	`20`	`Parent = parent;`
`21`	`21`	`LeftChild = left;`