Merge branch 'master' into beta

Author: justcoding121

src/Advanced.Algorithms/DataStructures/Dictionary/OrderedDictionary.cs

@@ -20,7 +20,7 @@ public class OrderedDictionary<K, V> : IEnumerable<KeyValuePair<K, V>> where K :
 
         public OrderedDictionary()
         {
-            binarySearchTree = new RedBlackTree<OrderedKeyValuePair<K, V>>(true);
+            binarySearchTree = new RedBlackTree<OrderedKeyValuePair<K, V>>();
         }
 
         /// <summary>

src/Advanced.Algorithms/DataStructures/HashSet/OrderedHashSet.cs

@@ -18,7 +18,7 @@ public class OrderedHashSet<T> : IEnumerable<T> where T : IComparable
 
         public OrderedHashSet()
         {
-            binarySearchTree = new RedBlackTree<T>(true);
+            binarySearchTree = new RedBlackTree<T>();
         }
 
         /// <summary>

src/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs

@@ -10,39 +10,40 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class RedBlackTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable
     {
+        //only used internally by Bentley-Ottmann sweepline algorithm for faster line swap operation.
         private readonly Dictionary<T, BSTNodeBase<T>> nodeLookUp;
+
         internal RedBlackTreeNode<T> Root { get; set; }
-        public int Count => Root == null ? 0 : Root.Count;
 
-        /// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations
-        /// at the cost of additional space.</param>
-        /// <param name="equalityComparer">Provide custom IEquality comparer for node lookup dictionary when enabled.</param>
-        public RedBlackTree(bool enableNodeLookUp = false, IEqualityComparer<T> equalityComparer = null)
-        {
-            if (enableNodeLookUp)
-            {
-                nodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);
-            }
-        }
+        public int Count => Root == null ? 0 : Root.Count;
 
         /// <summary>
-        /// Initialize the BST with given sorted keys.
+        /// Initialize the BST with given sorted keys optionally.
         /// Time complexity: O(n).
         /// </summary>
         /// <param name="collection">The sorted keys.</param>
         /// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations
         /// at the cost of additional space.</param>
         /// <param name="equalityComparer">Provide custom IEquality comparer for node lookup dictionary when enabled.</param>
-        public RedBlackTree(IEnumerable<T> sortedKeys, bool enableNodeLookUp = false, IEqualityComparer<T> equalityComparer = null)
-            : this(enableNodeLookUp, equalityComparer)
+        public RedBlackTree(IEnumerable<T> sortedKeys = null)
         {
-            ValidateCollection(sortedKeys);
-            var nodes = sortedKeys.Select(x => new RedBlackTreeNode<T>(null, x)).ToArray();
-            Root = (RedBlackTreeNode<T>)ToBST(nodes);
-            assignColors(Root);
-            assignCount(Root);
+            if (sortedKeys != null)
+            {
+                ValidateCollection(sortedKeys);
+                var nodes = sortedKeys.Select(x => new RedBlackTreeNode<T>(null, x)).ToArray();
+                Root = (RedBlackTreeNode<T>)ToBST(nodes);
+                assignColors(Root);
+                assignCount(Root);
+            }
         }
 
+        ///Special (internal only) constructor for Bentley-Ottmann sweep line algorithm for fast line swap.
+        /// <param name="equalityComparer">Provide custom IEquality comparer for node lookup dictionary.</param>
+        internal RedBlackTree(IEqualityComparer<T> equalityComparer)
+            : this()
+        {
+            nodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);
+        }
 
         /// <summary>
         ///  Time complexity: O(log(n))
@@ -200,7 +201,7 @@ public int Insert(T value)
                         return (node, insertionPosition);
                     }
 
-                    currentNode = currentNode.Right;  
+                    currentNode = currentNode.Right;
                 }
                 //current node is greater than new node
                 else if (compareResult > 0)

src/Advanced.Algorithms/Geometry/BentleyOttmann.cs

@@ -40,7 +40,7 @@ private void initialize(IEnumerable<Line> lineSegments)
         {
             SweepLine = new Line(new Point(0, 0), new Point(0, int.MaxValue), Tolerance);
 
-            currentlyTrackedLines = new RedBlackTree<Event>(true, pointComparer);
+            currentlyTrackedLines = new RedBlackTree<Event>(pointComparer);
             intersectionEvents = new Dictionary<Point, HashSet<Tuple<Event, Event>>>(pointComparer);
 
             verticalHorizontalLines = new HashSet<Event>();