Fix r-b tree constructor

justcoding121 · justcoding121 · commit 1fc8dfca50b5 · 2019-01-23T21:47:25.000-05:00
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/AvlTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/AvlTree.cs
@@ -411,7 +411,6 @@ public bool Contains(T value)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private AVLTreeNode<T> find(T value)
         {
             if (nodeLookUp != null)
@@ -424,7 +423,6 @@ private AVLTreeNode<T> find(T value)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private AVLTreeNode<T> find(AVLTreeNode<T> parent, T value)
         {
             if (parent == null)
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 
 namespace Advanced.Algorithms.DataStructures
 {
@@ -10,20 +11,26 @@ namespace Advanced.Algorithms.DataStructures
     /// </summary>
     public class RedBlackTree<T> : IEnumerable<T> where T : IComparable
     {
-        //if enabled, lookup will fasten deletion/insertion/exists operations. 
-        private readonly Dictionary<T, BSTNodeBase<T>> nodeLookUp;
-
         internal RedBlackTreeNode<T> Root { get; set; }
 
+        //if enabled, lookup will fasten deletion/insertion/exists operations. 
+        internal readonly Dictionary<T, BSTNodeBase<T>> NodeLookUp;
+
         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>
-        public RedBlackTree(bool enableNodeLookUp = false)
+        /// <param name="equalityComparer">Provide equality comparer for node lookup if enabled (required when T is not a value type).</param>
+        public RedBlackTree(bool enableNodeLookUp = false, IEqualityComparer<T> equalityComparer = null)
         {
             if (enableNodeLookUp)
             {
-                nodeLookUp = new Dictionary<T, BSTNodeBase<T>>();
+                if (!typeof(T).GetTypeInfo().IsValueType && equalityComparer == null)
+                {
+                    throw new ArgumentException("equalityComparer parameter is required when node lookup us enabled and T is not a value type.");
+                }
+
+                NodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);
             }
         }
 
@@ -34,7 +41,9 @@ public RedBlackTree(bool enableNodeLookUp = false)
         /// <param name="sortedCollection">The sorted initial collection.</param>
         /// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations
         /// at the cost of additional space.</param>
-        public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = false)
+        /// <param name="equalityComparer">Provide equality comparer for node lookup if enabled (required when T is not a value type).</param>
+        public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = false,
+            IEqualityComparer<T> equalityComparer = null)
         {
             BSTHelpers.ValidateSortedCollection(sortedCollection);
             var nodes = sortedCollection.Select(x => new RedBlackTreeNode<T>(null, x)).ToArray();
@@ -44,15 +53,13 @@ public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = fal
 
             if (enableNodeLookUp)
             {
-                nodeLookUp = nodes.ToDictionary(x => x.Value, x => x as BSTNodeBase<T>);
-            }
-        }
+                if (!typeof(T).GetTypeInfo().IsValueType && equalityComparer == null)
+                {
+                    throw new ArgumentException("equalityComparer parameter is required when node lookup us enabled and T is not a value type.");
+                }
 
-        ///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)
-        {
-            nodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);
+                NodeLookUp = nodes.ToDictionary(x => x.Value, x => x as BSTNodeBase<T>);
+            }
         }
 
         /// <summary>
@@ -65,12 +72,12 @@ public bool HasItem(T value)
                 return false;
             }
 
-            if (nodeLookUp != null)
+            if (NodeLookUp != null)
             {
-                return nodeLookUp.ContainsKey(value);
+                return NodeLookUp.ContainsKey(value);
             }
 
-            return find(value).Item1 != null;
+            return Find(value).Item1 != null;
         }
 
         /// <summary>
@@ -125,28 +132,25 @@ public T ElementAt(int index)
             return Root.KthSmallest(index).Value;
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         internal RedBlackTreeNode<T> FindNode(T value)
         {
-            return Root == null ? null : find(value).Item1;
+            return Root == null ? null : Find(value).Item1;
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         internal bool Exists(T value)
         {
             return FindNode(value) != null;
         }
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
-        private (RedBlackTreeNode<T>, int) find(T value)
+        internal (RedBlackTreeNode<T>, int) Find(T value)
         {
-            if (nodeLookUp != null)
+            if (NodeLookUp != null)
             {
-                if (nodeLookUp.ContainsKey(value))
+                if (NodeLookUp.ContainsKey(value))
                 {
-                    var node = (nodeLookUp[value] as RedBlackTreeNode<T>);
+                    var node = (NodeLookUp[value] as RedBlackTreeNode<T>);
                     return (node, Root.Position(value));
                 }
 
@@ -176,19 +180,19 @@ public int Insert(T value)
             if (Root == null)
             {
                 Root = new RedBlackTreeNode<T>(null, value) { NodeColor = RedBlackTreeNodeColor.Black };
-                if (nodeLookUp != null)
+                if (NodeLookUp != null)
                 {
-                    nodeLookUp[value] = Root;
+                    NodeLookUp[value] = Root;
                 }
 
                 return (Root, 0);
             }
 
             var newNode = insert(Root, value);
 
-            if (nodeLookUp != null)
+            if (NodeLookUp != null)
             {
-                nodeLookUp[value] = newNode.Item1;
+                NodeLookUp[value] = newNode.Item1;
             }
 
             return newNode;
@@ -376,7 +380,7 @@ public int Delete(T value)
                 return -1;
             }
 
-            var node = find(value);
+            var node = Find(value);
 
             if (node.Item1 == null)
             {
@@ -387,9 +391,9 @@ public int Delete(T value)
 
             delete(node.Item1);
 
-            if (nodeLookUp != null)
+            if (NodeLookUp != null)
             {
-                nodeLookUp.Remove(value);
+                NodeLookUp.Remove(value);
             }
 
             return position;
@@ -412,9 +416,9 @@ public T RemoveAt(int index)
 
             delete(node);
 
-            if (nodeLookUp != null)
+            if (NodeLookUp != null)
             {
-                nodeLookUp.Remove(deletedValue);
+                NodeLookUp.Remove(deletedValue);
             }
 
             return node.Value;
@@ -458,10 +462,10 @@ private void delete(RedBlackTreeNode<T> node)
                 {
                     var maxLeftNode = findMax(node.Left);
 
-                    if (nodeLookUp != null)
+                    if (NodeLookUp != null)
                     {
-                        nodeLookUp[node.Value] = maxLeftNode;
-                        nodeLookUp[maxLeftNode.Value] = node;
+                        NodeLookUp[node.Value] = maxLeftNode;
+                        NodeLookUp[maxLeftNode.Value] = node;
                     }
 
                     node.Value = maxLeftNode.Value;
@@ -853,28 +857,6 @@ public T NextHigher(T value)
             return next != null ? next.Value : default(T);
         }
 
-        ///Special (internal only) method for Bentley-Ottmann sweep line algorithm.
-        internal void Swap(T value1, T value2)
-        {
-            var node1 = find(value1).Item1;
-            var node2 = find(value2).Item1;
-
-            if (node1 == null || node2 == null)
-            {
-                throw new Exception("Value1, Value2 or both was not found in this BST.");
-            }
-
-            var tmp = node1.Value;
-            node1.Value = node2.Value;
-            node2.Value = tmp;
-
-            if (nodeLookUp != null)
-            {
-                nodeLookUp[node1.Value] = node1;
-                nodeLookUp[node2.Value] = node2;
-            }
-        }
-
         /// <summary>
         /// Descending enumerable.
         /// </summary>
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/SplayTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/SplayTree.cs
@@ -48,7 +48,6 @@ internal int GetHeight()
             return GetHeight(Root);
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         private int GetHeight(SplayTreeNode<T> node)
         {
             if (node == null)
@@ -164,7 +163,6 @@ public T RemoveAt(int index)
             return nodeToDelete.Value;
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         private void delete(SplayTreeNode<T> node, T value)
         {
             while (true)
@@ -328,7 +326,6 @@ private SplayTreeNode<T> FindMin(SplayTreeNode<T> node)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private SplayTreeNode<T> find(SplayTreeNode<T> parent, T value)
         {
             while (true)
@@ -491,7 +488,6 @@ private SplayTreeNode<T> leftRotate(SplayTreeNode<T> currentRoot)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private BSTNodeBase<T> find(T value)
         {
             return Root.Find<T>(value).Item1 as BSTNodeBase<T>;
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs
@@ -50,7 +50,6 @@ internal int GetHeight()
             return getHeight(Root);
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         private int getHeight(TreapTreeNode<T> node)
         {
             if (node == null)
@@ -167,7 +166,6 @@ public T RemoveAt(int index)
             return nodeToDelete.Value;
         }
 
-        //O(log(n)) worst O(n) for unbalanced tree
         private void delete(TreapTreeNode<T> node, T value)
         {
             while (true)
@@ -341,7 +339,6 @@ private TreapTreeNode<T> findMin(TreapTreeNode<T> node)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private TreapTreeNode<T> find(TreapTreeNode<T> parent, T value)
         {
             while (true)
@@ -486,7 +483,6 @@ private TreapTreeNode<T> leftRotate(TreapTreeNode<T> currentRoot)
 
         //find the node with the given identifier among descendants of parent and parent
         //uses pre-order traversal
-        //O(log(n)) worst O(n) for unbalanced tree
         private BSTNodeBase<T> find(T value)
         {
             return Root.Find<T>(value).Item1 as BSTNodeBase<T>;
diff --git a/src/Advanced.Algorithms/Geometry/BentleyOttmann.cs b/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>(pointComparer);
+            currentlyTrackedLines = new RedBlackTree<Event>(true, pointComparer);
             intersectionEvents = new Dictionary<Point, HashSet<Tuple<Event, Event>>>(pointComparer);
 
             verticalHorizontalLines = new HashSet<Event>();
@@ -151,7 +151,7 @@ public Dictionary<Point, List<Line>> FindIntersections(IEnumerable<Line> lineSeg
 
                         foreach (var item in intersectionLines)
                         {
-                            currentlyTrackedLines.Swap(item.Item1, item.Item2);
+                            swapBstNodes(currentlyTrackedLines, item.Item1, item.Item2);
 
                             var upperLine = item.Item1;
                             var upperUpper = currentlyTrackedLines.NextHigher(upperLine);
@@ -183,6 +183,24 @@ private void sweepTo(Event currentEvent)
             SweepLine = new Line(new Point(currentEvent.X, 0), new Point(currentEvent.X, int.MaxValue), Tolerance);
         }
 
+        internal void swapBstNodes(RedBlackTree<Event> currentlyTrackedLines, Event value1, Event value2)
+        {
+            var node1 = currentlyTrackedLines.Find(value1).Item1;
+            var node2 = currentlyTrackedLines.Find(value2).Item1;
+
+            if (node1 == null || node2 == null)
+            {
+                throw new Exception("Value1, Value2 or both was not found in this BST.");
+            }
+
+            var tmp = node1.Value;
+            node1.Value = node2.Value;
+            node2.Value = tmp;
+
+            currentlyTrackedLines.NodeLookUp[node1.Value] = node1;
+            currentlyTrackedLines.NodeLookUp[node2.Value] = node2;
+        }
+
         private void enqueueIntersectionEvent(Event currentEvent, Point intersection)
         {
             if (intersection == null)

Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,6 @@ public bool Contains(T value)`
`411`	`411`
`412`	`412`	`//find the node with the given identifier among descendants of parent and parent`
`413`	`413`	`//uses pre-order traversal`
`414`		`- //O(log(n)) worst O(n) for unbalanced tree`
`415`	`414`	`private AVLTreeNode<T> find(T value)`
`416`	`415`	`{`
`417`	`416`	`if (nodeLookUp != null)`
`@@ -424,7 +423,6 @@ private AVLTreeNode<T> find(T value)`
`424`	`423`
`425`	`424`	`//find the node with the given identifier among descendants of parent and parent`
`426`	`425`	`//uses pre-order traversal`
`427`		`- //O(log(n)) worst O(n) for unbalanced tree`
`428`	`426`	`private AVLTreeNode<T> find(AVLTreeNode<T> parent, T value)`
`429`	`427`	`{`
`430`	`428`	`if (parent == null)`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Collections;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Linq;`
	`5`	`+using System.Reflection;`
`5`	`6`
`6`	`7`	`namespace Advanced.Algorithms.DataStructures`
`7`	`8`	`{`
`@@ -10,20 +11,26 @@ namespace Advanced.Algorithms.DataStructures`
`10`	`11`	`/// </summary>`
`11`	`12`	`public class RedBlackTree<T> : IEnumerable<T> where T : IComparable`
`12`	`13`	`{`
`13`		`- //if enabled, lookup will fasten deletion/insertion/exists operations.`
`14`		`- private readonly Dictionary<T, BSTNodeBase<T>> nodeLookUp;`
`15`		`-`
`16`	`14`	`internal RedBlackTreeNode<T> Root { get; set; }`
`17`	`15`
	`16`	`+ //if enabled, lookup will fasten deletion/insertion/exists operations.`
	`17`	`+ internal readonly Dictionary<T, BSTNodeBase<T>> NodeLookUp;`
	`18`	`+`
`18`	`19`	`public int Count => Root == null ? 0 : Root.Count;`
`19`	`20`
`20`	`21`	`/// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations`
`21`	`22`	`/// at the cost of additional space.</param>`
`22`		`- public RedBlackTree(bool enableNodeLookUp = false)`
	`23`	`+ /// <param name="equalityComparer">Provide equality comparer for node lookup if enabled (required when T is not a value type).</param>`
	`24`	`+ public RedBlackTree(bool enableNodeLookUp = false, IEqualityComparer<T> equalityComparer = null)`
`23`	`25`	`{`
`24`	`26`	`if (enableNodeLookUp)`
`25`	`27`	`{`
`26`		`- nodeLookUp = new Dictionary<T, BSTNodeBase<T>>();`
	`28`	`+ if (!typeof(T).GetTypeInfo().IsValueType && equalityComparer == null)`
	`29`	`+ {`
	`30`	`+ throw new ArgumentException("equalityComparer parameter is required when node lookup us enabled and T is not a value type.");`
	`31`	`+ }`
	`32`	`+`
	`33`	`+ NodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);`
`27`	`34`	`}`
`28`	`35`	`}`
`29`	`36`
`@@ -34,7 +41,9 @@ public RedBlackTree(bool enableNodeLookUp = false)`
`34`	`41`	`/// <param name="sortedCollection">The sorted initial collection.</param>`
`35`	`42`	`/// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations`
`36`	`43`	`/// at the cost of additional space.</param>`
`37`		`- public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = false)`
	`44`	`+ /// <param name="equalityComparer">Provide equality comparer for node lookup if enabled (required when T is not a value type).</param>`
	`45`	`+ public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = false,`
	`46`	`+ IEqualityComparer<T> equalityComparer = null)`
`38`	`47`	`{`
`39`	`48`	`BSTHelpers.ValidateSortedCollection(sortedCollection);`
`40`	`49`	`var nodes = sortedCollection.Select(x => new RedBlackTreeNode<T>(null, x)).ToArray();`
`@@ -44,15 +53,13 @@ public RedBlackTree(IEnumerable<T> sortedCollection, bool enableNodeLookUp = fal`
`44`	`53`
`45`	`54`	`if (enableNodeLookUp)`
`46`	`55`	`{`
`47`		`- nodeLookUp = nodes.ToDictionary(x => x.Value, x => x as BSTNodeBase<T>);`
`48`		`- }`
`49`		`- }`
	`56`	`+ if (!typeof(T).GetTypeInfo().IsValueType && equalityComparer == null)`
	`57`	`+ {`
	`58`	`+ throw new ArgumentException("equalityComparer parameter is required when node lookup us enabled and T is not a value type.");`
	`59`	`+ }`
`50`	`60`
`51`		`- ///Special (internal only) constructor for Bentley-Ottmann sweep line algorithm for fast line swap.`
`52`		`- /// <param name="equalityComparer">Provide custom IEquality comparer for node lookup dictionary.</param>`
`53`		`- internal RedBlackTree(IEqualityComparer<T> equalityComparer)`
`54`		`- {`
`55`		`- nodeLookUp = new Dictionary<T, BSTNodeBase<T>>(equalityComparer);`
	`61`	`+ NodeLookUp = nodes.ToDictionary(x => x.Value, x => x as BSTNodeBase<T>);`
	`62`	`+ }`
`56`	`63`	`}`
`57`	`64`
`58`	`65`	`/// <summary>`
`@@ -65,12 +72,12 @@ public bool HasItem(T value)`
`65`	`72`	`return false;`
`66`	`73`	`}`
`67`	`74`
`68`		`- if (nodeLookUp != null)`
	`75`	`+ if (NodeLookUp != null)`
`69`	`76`	`{`
`70`		`- return nodeLookUp.ContainsKey(value);`
	`77`	`+ return NodeLookUp.ContainsKey(value);`
`71`	`78`	`}`
`72`	`79`
`73`		`- return find(value).Item1 != null;`
	`80`	`+ return Find(value).Item1 != null;`
`74`	`81`	`}`
`75`	`82`
`76`	`83`	`/// <summary>`
`@@ -125,28 +132,25 @@ public T ElementAt(int index)`
`125`	`132`	`return Root.KthSmallest(index).Value;`
`126`	`133`	`}`
`127`	`134`
`128`		`- //O(log(n)) worst O(n) for unbalanced tree`
`129`	`135`	`internal RedBlackTreeNode<T> FindNode(T value)`
`130`	`136`	`{`
`131`		`- return Root == null ? null : find(value).Item1;`
	`137`	`+ return Root == null ? null : Find(value).Item1;`
`132`	`138`	`}`
`133`	`139`
`134`		`- //O(log(n)) worst O(n) for unbalanced tree`
`135`	`140`	`internal bool Exists(T value)`
`136`	`141`	`{`
`137`	`142`	`return FindNode(value) != null;`
`138`	`143`	`}`
`139`	`144`
`140`	`145`	`//find the node with the given identifier among descendants of parent and parent`
`141`	`146`	`//uses pre-order traversal`
`142`		`- //O(log(n)) worst O(n) for unbalanced tree`
`143`		`- private (RedBlackTreeNode<T>, int) find(T value)`
	`147`	`+ internal (RedBlackTreeNode<T>, int) Find(T value)`
`144`	`148`	`{`
`145`		`- if (nodeLookUp != null)`
	`149`	`+ if (NodeLookUp != null)`
`146`	`150`	`{`
`147`		`- if (nodeLookUp.ContainsKey(value))`
	`151`	`+ if (NodeLookUp.ContainsKey(value))`
`148`	`152`	`{`
`149`		`- var node = (nodeLookUp[value] as RedBlackTreeNode<T>);`
	`153`	`+ var node = (NodeLookUp[value] as RedBlackTreeNode<T>);`
`150`	`154`	`return (node, Root.Position(value));`
`151`	`155`	`}`
`152`	`156`
`@@ -176,19 +180,19 @@ public int Insert(T value)`
`176`	`180`	`if (Root == null)`
`177`	`181`	`{`
`178`	`182`	`Root = new RedBlackTreeNode<T>(null, value) { NodeColor = RedBlackTreeNodeColor.Black };`
`179`		`- if (nodeLookUp != null)`
	`183`	`+ if (NodeLookUp != null)`
`180`	`184`	`{`
`181`		`- nodeLookUp[value] = Root;`
	`185`	`+ NodeLookUp[value] = Root;`
`182`	`186`	`}`
`183`	`187`
`184`	`188`	`return (Root, 0);`
`185`	`189`	`}`
`186`	`190`
`187`	`191`	`var newNode = insert(Root, value);`
`188`	`192`
`189`		`- if (nodeLookUp != null)`
	`193`	`+ if (NodeLookUp != null)`
`190`	`194`	`{`
`191`		`- nodeLookUp[value] = newNode.Item1;`
	`195`	`+ NodeLookUp[value] = newNode.Item1;`
`192`	`196`	`}`
`193`	`197`
`194`	`198`	`return newNode;`
`@@ -376,7 +380,7 @@ public int Delete(T value)`
`376`	`380`	`return -1;`
`377`	`381`	`}`
`378`	`382`
`379`		`- var node = find(value);`
	`383`	`+ var node = Find(value);`
`380`	`384`
`381`	`385`	`if (node.Item1 == null)`
`382`	`386`	`{`
`@@ -387,9 +391,9 @@ public int Delete(T value)`
`387`	`391`
`388`	`392`	`delete(node.Item1);`
`389`	`393`
`390`		`- if (nodeLookUp != null)`
	`394`	`+ if (NodeLookUp != null)`
`391`	`395`	`{`
`392`		`- nodeLookUp.Remove(value);`
	`396`	`+ NodeLookUp.Remove(value);`
`393`	`397`	`}`
`394`	`398`
`395`	`399`	`return position;`
`@@ -412,9 +416,9 @@ public T RemoveAt(int index)`
`412`	`416`
`413`	`417`	`delete(node);`
`414`	`418`
`415`		`- if (nodeLookUp != null)`
	`419`	`+ if (NodeLookUp != null)`
`416`	`420`	`{`
`417`		`- nodeLookUp.Remove(deletedValue);`
	`421`	`+ NodeLookUp.Remove(deletedValue);`
`418`	`422`	`}`
`419`	`423`
`420`	`424`	`return node.Value;`
`@@ -458,10 +462,10 @@ private void delete(RedBlackTreeNode<T> node)`
`458`	`462`	`{`
`459`	`463`	`var maxLeftNode = findMax(node.Left);`
`460`	`464`
`461`		`- if (nodeLookUp != null)`
	`465`	`+ if (NodeLookUp != null)`
`462`	`466`	`{`
`463`		`- nodeLookUp[node.Value] = maxLeftNode;`
`464`		`- nodeLookUp[maxLeftNode.Value] = node;`
	`467`	`+ NodeLookUp[node.Value] = maxLeftNode;`
	`468`	`+ NodeLookUp[maxLeftNode.Value] = node;`
`465`	`469`	`}`
`466`	`470`
`467`	`471`	`node.Value = maxLeftNode.Value;`
`@@ -853,28 +857,6 @@ public T NextHigher(T value)`
`853`	`857`	`return next != null ? next.Value : default(T);`
`854`	`858`	`}`
`855`	`859`
`856`		`- ///Special (internal only) method for Bentley-Ottmann sweep line algorithm.`
`857`		`- internal void Swap(T value1, T value2)`
`858`		`- {`
`859`		`- var node1 = find(value1).Item1;`
`860`		`- var node2 = find(value2).Item1;`
`861`		`-`
`862`		`- if (node1 == null \|\| node2 == null)`
`863`		`- {`
`864`		`- throw new Exception("Value1, Value2 or both was not found in this BST.");`
`865`		`- }`
`866`		`-`
`867`		`- var tmp = node1.Value;`
`868`		`- node1.Value = node2.Value;`
`869`		`- node2.Value = tmp;`
`870`		`-`
`871`		`- if (nodeLookUp != null)`
`872`		`- {`
`873`		`- nodeLookUp[node1.Value] = node1;`
`874`		`- nodeLookUp[node2.Value] = node2;`
`875`		`- }`
`876`		`- }`
`877`		`-`
`878`	`860`	`/// <summary>`
`879`	`861`	`/// Descending enumerable.`
`880`	`862`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,6 @@ internal int GetHeight()`
`48`	`48`	`return GetHeight(Root);`
`49`	`49`	`}`
`50`	`50`
`51`		`- //O(log(n)) worst O(n) for unbalanced tree`
`52`	`51`	`private int GetHeight(SplayTreeNode<T> node)`
`53`	`52`	`{`
`54`	`53`	`if (node == null)`
`@@ -164,7 +163,6 @@ public T RemoveAt(int index)`
`164`	`163`	`return nodeToDelete.Value;`
`165`	`164`	`}`
`166`	`165`
`167`		`- //O(log(n)) worst O(n) for unbalanced tree`
`168`	`166`	`private void delete(SplayTreeNode<T> node, T value)`
`169`	`167`	`{`
`170`	`168`	`while (true)`
`@@ -328,7 +326,6 @@ private SplayTreeNode<T> FindMin(SplayTreeNode<T> node)`
`328`	`326`
`329`	`327`	`//find the node with the given identifier among descendants of parent and parent`
`330`	`328`	`//uses pre-order traversal`
`331`		`- //O(log(n)) worst O(n) for unbalanced tree`
`332`	`329`	`private SplayTreeNode<T> find(SplayTreeNode<T> parent, T value)`
`333`	`330`	`{`
`334`	`331`	`while (true)`
`@@ -491,7 +488,6 @@ private SplayTreeNode<T> leftRotate(SplayTreeNode<T> currentRoot)`
`491`	`488`
`492`	`489`	`//find the node with the given identifier among descendants of parent and parent`
`493`	`490`	`//uses pre-order traversal`
`494`		`- //O(log(n)) worst O(n) for unbalanced tree`
`495`	`491`	`private BSTNodeBase<T> find(T value)`
`496`	`492`	`{`
`497`	`493`	`return Root.Find<T>(value).Item1 as BSTNodeBase<T>;`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,6 @@ internal int GetHeight()`
`50`	`50`	`return getHeight(Root);`
`51`	`51`	`}`
`52`	`52`
`53`		`- //O(log(n)) worst O(n) for unbalanced tree`
`54`	`53`	`private int getHeight(TreapTreeNode<T> node)`
`55`	`54`	`{`
`56`	`55`	`if (node == null)`
`@@ -167,7 +166,6 @@ public T RemoveAt(int index)`
`167`	`166`	`return nodeToDelete.Value;`
`168`	`167`	`}`
`169`	`168`
`170`		`- //O(log(n)) worst O(n) for unbalanced tree`
`171`	`169`	`private void delete(TreapTreeNode<T> node, T value)`
`172`	`170`	`{`
`173`	`171`	`while (true)`
`@@ -341,7 +339,6 @@ private TreapTreeNode<T> findMin(TreapTreeNode<T> node)`
`341`	`339`
`342`	`340`	`//find the node with the given identifier among descendants of parent and parent`
`343`	`341`	`//uses pre-order traversal`
`344`		`- //O(log(n)) worst O(n) for unbalanced tree`
`345`	`342`	`private TreapTreeNode<T> find(TreapTreeNode<T> parent, T value)`
`346`	`343`	`{`
`347`	`344`	`while (true)`
`@@ -486,7 +483,6 @@ private TreapTreeNode<T> leftRotate(TreapTreeNode<T> currentRoot)`
`486`	`483`
`487`	`484`	`//find the node with the given identifier among descendants of parent and parent`
`488`	`485`	`//uses pre-order traversal`
`489`		`- //O(log(n)) worst O(n) for unbalanced tree`
`490`	`486`	`private BSTNodeBase<T> find(T value)`
`491`	`487`	`{`
`492`	`488`	`return Root.Find<T>(value).Item1 as BSTNodeBase<T>;`