optimize bst item position for insertion/deletion

justcoding121 · justcoding121 · commit 9fd1ec8878df · 2018-12-25T14:50:14.000-05:00
diff --git a/src/Advanced.Algorithms/Advanced.Algorithms.csproj b/src/Advanced.Algorithms/Advanced.Algorithms.csproj
@@ -8,6 +8,7 @@
     <AssemblyOriginatorKeyFile>StrongNameKey.snk</AssemblyOriginatorKeyFile>
     <DelaySign>False</DelaySign>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -17,12 +18,13 @@
     <EmbeddedResource Remove="DynamicProgramming\**" />
     <None Remove="Binary\**" />
     <None Remove="DynamicProgramming\**" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>
     <Compile Include="Binary\BaseConversion.cs" />
     <Compile Include="Binary\Logarithm.cs" />
     <Compile Include="Binary\GCD.cs" />
   </ItemGroup>
-
+ 
 </Project>
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/IntervalTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/IntervalTree.cs
@@ -304,12 +304,10 @@ internal void Insert(OneDimentionalInterval<T> newInterval)
             if (existing != null)
             {
                 existing.Value.End.Add(newInterval.End[0]);
-
             }
             else
             {
-
-                existing = redBlackTree.InsertAndReturnNode(newInterval);
+                existing = redBlackTree.InsertAndReturnNode(newInterval).Item1;
             }
             updateMax(existing);
             Count++;
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/RedBlackTree.cs
@@ -59,7 +59,7 @@ public bool HasItem(T value)
                 return nodeLookUp.ContainsKey(value);
             }
 
-            return find(value) != null;
+            return find(value).Item1 != null;
         }
 
         /// <summary>
@@ -117,7 +117,7 @@ public T ElementAt(int index)
         //O(log(n)) worst O(n) for unbalanced tree
         internal RedBlackTreeNode<T> FindNode(T value)
         {
-            return Root == null ? null : find(value);
+            return Root == null ? null : find(value).Item1;
         }
 
         //O(log(n)) worst O(n) for unbalanced tree
@@ -129,14 +129,15 @@ internal bool Exists(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 RedBlackTreeNode<T> find(T value)
+        private (RedBlackTreeNode<T>, int) find(T value)
         {
             if (nodeLookUp != null)
             {
-                return nodeLookUp[value] as RedBlackTreeNode<T>;
+                return (nodeLookUp[value] as RedBlackTreeNode<T>, Root.Position(value));
             }
 
-            return Root.Find<T>(value) as RedBlackTreeNode<T>;
+            var result = Root.Find(value);
+            return (result.Item1 as RedBlackTreeNode<T>, result.Item2);
         }
 
         /// <summary>
@@ -146,13 +147,13 @@ private RedBlackTreeNode<T> find(T value)
         public int Insert(T value)
         {
             var node = InsertAndReturnNode(value);
-            return Root.Position(value);
+            return node.Item2;
         }
 
         /// <summary>
         ///  Time complexity: O(log(n))
         /// </summary>
-        internal RedBlackTreeNode<T> InsertAndReturnNode(T value)
+        internal (RedBlackTreeNode<T>, int) InsertAndReturnNode(T value)
         {
             //empty tree
             if (Root == null)
@@ -163,39 +164,43 @@ internal RedBlackTreeNode<T> InsertAndReturnNode(T value)
                     nodeLookUp[value] = Root;
                 }
 
-                return Root;
+                return (Root, 0);
             }
 
-            var newNode = insert(Root, value);
+            var newNode = Insert(Root, value);
 
             if (nodeLookUp != null)
             {
-                nodeLookUp[value] = newNode;
+                nodeLookUp[value] = newNode.Item1;
             }
 
             return newNode;
         }
 
         //O(log(n)) always
-        private RedBlackTreeNode<T> insert(RedBlackTreeNode<T> currentNode, T newNodeValue)
+        private (RedBlackTreeNode<T>, int) Insert(RedBlackTreeNode<T> currentNode, T newNodeValue)
         {
+            var insertionPosition = 0;
+
             while (true)
             {
                 var compareResult = currentNode.Value.CompareTo(newNodeValue);
 
                 //current node is less than new item
                 if (compareResult < 0)
                 {
+                    insertionPosition += (currentNode.Left != null ? currentNode.Left.Count : 0) + 1;
+
                     //no right child
                     if (currentNode.Right == null)
                     {
                         //insert
                         var node = currentNode.Right = new RedBlackTreeNode<T>(currentNode, newNodeValue);
                         balanceInsertion(currentNode.Right);
-                        return node;
+                        return (node, insertionPosition);
                     }
 
-                    currentNode = currentNode.Right;
+                    currentNode = currentNode.Right;  
                 }
                 //current node is greater than new node
                 else if (compareResult > 0)
@@ -205,7 +210,7 @@ private RedBlackTreeNode<T> insert(RedBlackTreeNode<T> currentNode, T newNodeVal
                         //insert
                         var node = currentNode.Left = new RedBlackTreeNode<T>(currentNode, newNodeValue);
                         balanceInsertion(currentNode.Left);
-                        return node;
+                        return (node, insertionPosition);
                     }
 
                     currentNode = currentNode.Left;
@@ -356,14 +361,14 @@ public int Delete(T value)
 
             var node = find(value);
 
-            if (node == null)
+            if (node.Item1 == null)
             {
                 return -1;
             }
 
-            var position = Root.Position(value);
+            var position = node.Item2;
 
-            delete(node);
+            delete(node.Item1);
 
             if (nodeLookUp != null)
             {
@@ -830,8 +835,8 @@ public T NextHigher(T value)
 
         internal void Swap(T value1, T value2)
         {
-            var node1 = find(value1);
-            var node2 = find(value2);
+            var node1 = find(value1).Item1;
+            var node2 = find(value2).Item1;
 
             if (node1 == null || node2 == null)
             {
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/Shared/BSTExtensions.cs b/src/Advanced.Algorithms/DataStructures/Tree/Shared/BSTExtensions.cs
@@ -8,20 +8,23 @@ internal static class BSTExtensions
         //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
-        internal static BSTNodeBase<T> Find<T>(this BSTNodeBase<T> current, T value) where T : IComparable
+        internal static (BSTNodeBase<T>, int) Find<T>(this BSTNodeBase<T> current, T value) where T : IComparable
         {
+            int position = 0;
+
             while (true)
             {
                 if (current == null)
                 {
-                    return null;
+                    return (null, -1);
                 }
 
                 var compareResult = current.Value.CompareTo(value);
 
                 if (compareResult == 0)
                 {
-                    return current;
+                    position += (current.Left != null ? current.Left.Count : 0);
+                    return (current, position);
                 }
 
                 if (compareResult > 0)
@@ -30,7 +33,8 @@ internal static BSTNodeBase<T> Find<T>(this BSTNodeBase<T> current, T value) whe
                 }
                 else
                 {
-                    current = current.Right;
+                    position += (current.Left != null ? current.Left.Count : 0) + 1;
+                    current = current.Right;           
                 }
             }
         }
diff --git a/tests/Advanced.Algorithms.Tests/DataStructures/Tree/RedBlackTree_Tests.cs b/tests/Advanced.Algorithms.Tests/DataStructures/Tree/RedBlackTree_Tests.cs
@@ -68,7 +68,8 @@ public void RedBlackTree_Accuracy_Test()
 
             for (int i = 0; i < nodeCount; i++)
             {
-                tree.Insert(randomNumbers[i]);
+                var index = tree.Insert(randomNumbers[i]);
+                Assert.AreEqual(index, tree.IndexOf(randomNumbers[i]));
                 Assert.IsTrue(tree.HasItem(randomNumbers[i]));
                 Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));
                 tree.Root.VerifyCount();
@@ -98,17 +99,18 @@ public void RedBlackTree_Accuracy_Test()
 
             for (int i = 0; i < nodeCount; i++)
             {
-                if(rnd.NextDouble() >= 0.5)
+                if (rnd.NextDouble() >= 0.5)
                 {
-                    tree.Delete(randomNumbers[i]);
+                    var index = tree.IndexOf(randomNumbers[i]);
+                    Assert.AreEqual(index, tree.Delete(randomNumbers[i]));
                 }
                 else
                 {
                     var index = tree.IndexOf(randomNumbers[i]);
                     Assert.AreEqual(tree.ElementAt(index), randomNumbers[i]);
                     tree.RemoveAt(index);
                 }
-                
+
                 Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));
                 tree.Root.VerifyCount();
                 var actualHeight = tree.Root.GetHeight();

Original file line number	Diff line number	Diff line change
`@@ -304,12 +304,10 @@ internal void Insert(OneDimentionalInterval<T> newInterval)`
`304`	`304`	`if (existing != null)`
`305`	`305`	`{`
`306`	`306`	`existing.Value.End.Add(newInterval.End[0]);`
`307`		`-`
`308`	`307`	`}`
`309`	`308`	`else`
`310`	`309`	`{`
`311`		`-`
`312`		`- existing = redBlackTree.InsertAndReturnNode(newInterval);`
	`310`	`+ existing = redBlackTree.InsertAndReturnNode(newInterval).Item1;`
`313`	`311`	`}`
`314`	`312`	`updateMax(existing);`
`315`	`313`	`Count++;`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public bool HasItem(T value)`
`59`	`59`	`return nodeLookUp.ContainsKey(value);`
`60`	`60`	`}`
`61`	`61`
`62`		`- return find(value) != null;`
	`62`	`+ return find(value).Item1 != null;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`/// <summary>`
`@@ -117,7 +117,7 @@ public T ElementAt(int index)`
`117`	`117`	`//O(log(n)) worst O(n) for unbalanced tree`
`118`	`118`	`internal RedBlackTreeNode<T> FindNode(T value)`
`119`	`119`	`{`
`120`		`- return Root == null ? null : find(value);`
	`120`	`+ return Root == null ? null : find(value).Item1;`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`//O(log(n)) worst O(n) for unbalanced tree`
`@@ -129,14 +129,15 @@ internal bool Exists(T value)`
`129`	`129`	`//find the node with the given identifier among descendants of parent and parent`
`130`	`130`	`//uses pre-order traversal`
`131`	`131`	`//O(log(n)) worst O(n) for unbalanced tree`
`132`		`- private RedBlackTreeNode<T> find(T value)`
	`132`	`+ private (RedBlackTreeNode<T>, int) find(T value)`
`133`	`133`	`{`
`134`	`134`	`if (nodeLookUp != null)`
`135`	`135`	`{`
`136`		`- return nodeLookUp[value] as RedBlackTreeNode<T>;`
	`136`	`+ return (nodeLookUp[value] as RedBlackTreeNode<T>, Root.Position(value));`
`137`	`137`	`}`
`138`	`138`
`139`		`- return Root.Find<T>(value) as RedBlackTreeNode<T>;`
	`139`	`+ var result = Root.Find(value);`
	`140`	`+ return (result.Item1 as RedBlackTreeNode<T>, result.Item2);`
`140`	`141`	`}`
`141`	`142`
`142`	`143`	`/// <summary>`
`@@ -146,13 +147,13 @@ private RedBlackTreeNode<T> find(T value)`
`146`	`147`	`public int Insert(T value)`
`147`	`148`	`{`
`148`	`149`	`var node = InsertAndReturnNode(value);`
`149`		`- return Root.Position(value);`
	`150`	`+ return node.Item2;`
`150`	`151`	`}`
`151`	`152`
`152`	`153`	`/// <summary>`
`153`	`154`	`/// Time complexity: O(log(n))`
`154`	`155`	`/// </summary>`
`155`		`- internal RedBlackTreeNode<T> InsertAndReturnNode(T value)`
	`156`	`+ internal (RedBlackTreeNode<T>, int) InsertAndReturnNode(T value)`
`156`	`157`	`{`
`157`	`158`	`//empty tree`
`158`	`159`	`if (Root == null)`
`@@ -163,39 +164,43 @@ internal RedBlackTreeNode<T> InsertAndReturnNode(T value)`
`163`	`164`	`nodeLookUp[value] = Root;`
`164`	`165`	`}`
`165`	`166`
`166`		`- return Root;`
	`167`	`+ return (Root, 0);`
`167`	`168`	`}`
`168`	`169`
`169`		`- var newNode = insert(Root, value);`
	`170`	`+ var newNode = Insert(Root, value);`
`170`	`171`
`171`	`172`	`if (nodeLookUp != null)`
`172`	`173`	`{`
`173`		`- nodeLookUp[value] = newNode;`
	`174`	`+ nodeLookUp[value] = newNode.Item1;`
`174`	`175`	`}`
`175`	`176`
`176`	`177`	`return newNode;`
`177`	`178`	`}`
`178`	`179`
`179`	`180`	`//O(log(n)) always`
`180`		`- private RedBlackTreeNode<T> insert(RedBlackTreeNode<T> currentNode, T newNodeValue)`
	`181`	`+ private (RedBlackTreeNode<T>, int) Insert(RedBlackTreeNode<T> currentNode, T newNodeValue)`
`181`	`182`	`{`
	`183`	`+ var insertionPosition = 0;`
	`184`	`+`
`182`	`185`	`while (true)`
`183`	`186`	`{`
`184`	`187`	`var compareResult = currentNode.Value.CompareTo(newNodeValue);`
`185`	`188`
`186`	`189`	`//current node is less than new item`
`187`	`190`	`if (compareResult < 0)`
`188`	`191`	`{`
	`192`	`+ insertionPosition += (currentNode.Left != null ? currentNode.Left.Count : 0) + 1;`
	`193`	`+`
`189`	`194`	`//no right child`
`190`	`195`	`if (currentNode.Right == null)`
`191`	`196`	`{`
`192`	`197`	`//insert`
`193`	`198`	`var node = currentNode.Right = new RedBlackTreeNode<T>(currentNode, newNodeValue);`
`194`	`199`	`balanceInsertion(currentNode.Right);`
`195`		`- return node;`
	`200`	`+ return (node, insertionPosition);`
`196`	`201`	`}`
`197`	`202`
`198`		`- currentNode = currentNode.Right;`
	`203`	`+ currentNode = currentNode.Right;`
`199`	`204`	`}`
`200`	`205`	`//current node is greater than new node`
`201`	`206`	`else if (compareResult > 0)`
`@@ -205,7 +210,7 @@ private RedBlackTreeNode<T> insert(RedBlackTreeNode<T> currentNode, T newNodeVal`
`205`	`210`	`//insert`
`206`	`211`	`var node = currentNode.Left = new RedBlackTreeNode<T>(currentNode, newNodeValue);`
`207`	`212`	`balanceInsertion(currentNode.Left);`
`208`		`- return node;`
	`213`	`+ return (node, insertionPosition);`
`209`	`214`	`}`
`210`	`215`
`211`	`216`	`currentNode = currentNode.Left;`
`@@ -356,14 +361,14 @@ public int Delete(T value)`
`356`	`361`
`357`	`362`	`var node = find(value);`
`358`	`363`
`359`		`- if (node == null)`
	`364`	`+ if (node.Item1 == null)`
`360`	`365`	`{`
`361`	`366`	`return -1;`
`362`	`367`	`}`
`363`	`368`
`364`		`- var position = Root.Position(value);`
	`369`	`+ var position = node.Item2;`
`365`	`370`
`366`		`- delete(node);`
	`371`	`+ delete(node.Item1);`
`367`	`372`
`368`	`373`	`if (nodeLookUp != null)`
`369`	`374`	`{`
`@@ -830,8 +835,8 @@ public T NextHigher(T value)`
`830`	`835`
`831`	`836`	`internal void Swap(T value1, T value2)`
`832`	`837`	`{`
`833`		`- var node1 = find(value1);`
`834`		`- var node2 = find(value2);`
	`838`	`+ var node1 = find(value1).Item1;`
	`839`	`+ var node2 = find(value2).Item1;`
`835`	`840`
`836`	`841`	`if (node1 == null \|\| node2 == null)`
`837`	`842`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,23 @@ internal static class BSTExtensions`
`8`	`8`	`//find the node with the given identifier among descendants of parent and parent`
`9`	`9`	`//uses pre-order traversal`
`10`	`10`	`//O(log(n)) worst O(n) for unbalanced tree`
`11`		`- internal static BSTNodeBase<T> Find<T>(this BSTNodeBase<T> current, T value) where T : IComparable`
	`11`	`+ internal static (BSTNodeBase<T>, int) Find<T>(this BSTNodeBase<T> current, T value) where T : IComparable`
`12`	`12`	`{`
	`13`	`+ int position = 0;`
	`14`	`+`
`13`	`15`	`while (true)`
`14`	`16`	`{`
`15`	`17`	`if (current == null)`
`16`	`18`	`{`
`17`		`- return null;`
	`19`	`+ return (null, -1);`
`18`	`20`	`}`
`19`	`21`
`20`	`22`	`var compareResult = current.Value.CompareTo(value);`
`21`	`23`
`22`	`24`	`if (compareResult == 0)`
`23`	`25`	`{`
`24`		`- return current;`
	`26`	`+ position += (current.Left != null ? current.Left.Count : 0);`
	`27`	`+ return (current, position);`
`25`	`28`	`}`
`26`	`29`
`27`	`30`	`if (compareResult > 0)`
`@@ -30,7 +33,8 @@ internal static BSTNodeBase<T> Find<T>(this BSTNodeBase<T> current, T value) whe`
`30`	`33`	`}`
`31`	`34`	`else`
`32`	`35`	`{`
`33`		`- current = current.Right;`
	`36`	`+ position += (current.Left != null ? current.Left.Count : 0) + 1;`
	`37`	`+ current = current.Right;`
`34`	`38`	`}`
`35`	`39`	`}`
`36`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,8 @@ public void RedBlackTree_Accuracy_Test()`
`68`	`68`
`69`	`69`	`for (int i = 0; i < nodeCount; i++)`
`70`	`70`	`{`
`71`		`- tree.Insert(randomNumbers[i]);`
	`71`	`+ var index = tree.Insert(randomNumbers[i]);`
	`72`	`+ Assert.AreEqual(index, tree.IndexOf(randomNumbers[i]));`
`72`	`73`	`Assert.IsTrue(tree.HasItem(randomNumbers[i]));`
`73`	`74`	`Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));`
`74`	`75`	`tree.Root.VerifyCount();`
`@@ -98,17 +99,18 @@ public void RedBlackTree_Accuracy_Test()`
`98`	`99`
`99`	`100`	`for (int i = 0; i < nodeCount; i++)`
`100`	`101`	`{`
`101`		`- if(rnd.NextDouble() >= 0.5)`
	`102`	`+ if (rnd.NextDouble() >= 0.5)`
`102`	`103`	`{`
`103`		`- tree.Delete(randomNumbers[i]);`
	`104`	`+ var index = tree.IndexOf(randomNumbers[i]);`
	`105`	`+ Assert.AreEqual(index, tree.Delete(randomNumbers[i]));`
`104`	`106`	`}`
`105`	`107`	`else`
`106`	`108`	`{`
`107`	`109`	`var index = tree.IndexOf(randomNumbers[i]);`
`108`	`110`	`Assert.AreEqual(tree.ElementAt(index), randomNumbers[i]);`
`109`	`111`	`tree.RemoveAt(index);`
`110`	`112`	`}`
`111`		`-`
	`113`	`+`
`112`	`114`	`Assert.IsTrue(tree.Root.IsBinarySearchTree(int.MinValue, int.MaxValue));`
`113`	`115`	`tree.Root.VerifyCount();`
`114`	`116`	`var actualHeight = tree.Root.GetHeight();`