Max optimization and DescEnumerable

Author: justcoding121

src/Advanced.Algorithms/DataStructures/Tree/B+Tree.cs

@@ -14,24 +14,26 @@ public class BpTree<T> : IEnumerable<T> where T : IComparable
         internal BpTreeNode<T> Root;
 
         /// <summary>
-        ///Keep a reference of Bottom Left Node
-        ///For faster enumeration with IEnumerable implementation using Next pointer
+        /// Keep a reference of Bottom Left Node
+        /// for fast ascending/descending enumeration using Next pointer.
+        /// See IEnumerable & IEnumerableDesc implementation at bottom.
         /// </summary>
         internal BpTreeNode<T> BottomLeftNode;
+        internal BpTreeNode<T> BottomRightNode;
 
         private readonly int maxKeysPerNode;
         private readonly int minKeysPerNode;
 
         /// <summary>
-        /// Time complexity: O(log(n)).
+        /// Time complexity: O(1).
         /// </summary>
         public T Max
         {
             get
             {
                 if (Root == null) return default(T);
 
-                var maxNode = findMaxNode(Root);
+                var maxNode = BottomRightNode;
                 return maxNode.Keys[maxNode.KeyCount - 1];
             }
         }
@@ -50,7 +52,7 @@ public T Min
             }
         }
 
-        public BpTree(int maxKeysPerNode)
+        public BpTree(int maxKeysPerNode = 3)
         {
             if (maxKeysPerNode < 3)
             {
@@ -122,6 +124,7 @@ public void Insert(T newValue)
                 Root.KeyCount++;
                 Count++;
                 BottomLeftNode = Root;
+                BottomRightNode = Root;
                 return;
             }
 
@@ -204,6 +207,11 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,
                     right.Next = node.Next;
                     node.Next.Prev = right;
                 }
+                else
+                {
+                    //bottom right most node
+                    BottomRightNode = right;
+                }
 
                 if (node.Prev != null)
                 {
@@ -212,7 +220,7 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,
                 }
                 else
                 {
-                    //left most bottom node
+                    //bottom left most node
                     BottomLeftNode = left;
                 }
             }
@@ -559,7 +567,10 @@ private void sandwich(BpTreeNode<T> leftSibling, BpTreeNode<T> rightSibling, T d
                     newNode.Next = rightSibling.Next;
                     rightSibling.Next.Prev = newNode;
                 }
-
+                else
+                {
+                    BottomRightNode = newNode;
+                }
             }
 
             var newIndex = 0;
@@ -912,6 +923,14 @@ private void removeAt<TS>(TS[] array, int index)
             Array.Copy(array, index + 1, array, index, array.Length - index - 1);
         }
 
+        /// <summary>
+        /// Descending enumerable.
+        /// </summary>
+        public IEnumerable<T> AsEnumerableDesc()
+        {
+            return GetEnumeratorDesc().AsEnumerable();
+        }
+
         //Implementation for the GetEnumerator method.
         IEnumerator IEnumerable.GetEnumerator()
         {
@@ -922,6 +941,11 @@ public IEnumerator<T> GetEnumerator()
         {
             return new BpTreeEnumerator<T>(this);
         }
+
+        public IEnumerator<T> GetEnumeratorDesc()
+        {
+            return new BpTreeEnumerator<T>(this, false);
+        }
     }
 
     internal class BpTreeNode<T> : BNode<T> where T : IComparable
@@ -970,14 +994,21 @@ internal override BNode<T>[] GetChildren()
 
     internal class BpTreeEnumerator<T> : IEnumerator<T> where T : IComparable
     {
-        private BpTreeNode<T> bottomLeftNode;
+        private readonly bool asc;
+
+        private BpTreeNode<T> startNode;
         private BpTreeNode<T> current;
-        private int index = -1;
 
-        internal BpTreeEnumerator(BpTree<T> tree)
+        private int index;
+
+        internal BpTreeEnumerator(BpTree<T> tree, bool asc = true)
         {
-            bottomLeftNode = tree.BottomLeftNode;
-            current = bottomLeftNode;
+            this.asc = asc;
+
+            startNode = asc ? tree.BottomLeftNode : tree.BottomRightNode;
+            current = startNode;
+
+            index = asc ? -1 : current.KeyCount;
         }
 
         public bool MoveNext()
@@ -987,22 +1018,38 @@ public bool MoveNext()
                 return false;
             }
 
-            if (index + 1 < current.KeyCount)
+            if (asc)
             {
-                index++;
-                return true;
+                if (index + 1 < current.KeyCount)
+                {
+                    index++;
+                    return true;
+                }
+            }
+            else
+            {
+                if (index - 1 >= 0)
+                {
+                    index--;
+                    return true;
+                }
             }
 
-            current = current.Next;
-            index = 0;
+            current = asc ? current.Next : current.Prev;
+
+            var canMove = current != null && current.KeyCount > 0;
+            if (canMove)
+            {
+                index = asc ? 0 : current.KeyCount - 1;
+            }
 
-            return current != null && current.KeyCount > 0;
+            return canMove;
         }
 
         public void Reset()
         {
-            current = bottomLeftNode;
-            index = -1;
+            current = startNode;
+            index = asc ? -1 : current.KeyCount;
         }
 
         object IEnumerator.Current => Current;
@@ -1018,8 +1065,7 @@ public T Current
         public void Dispose()
         {
             current = null;
-            bottomLeftNode = null;
-            index = -1;
+            startNode = null;
         }
     }
 

tests/Advanced.Algorithms.Tests/DataStructures/Tree/B+Tree_Tests.cs

@@ -103,7 +103,13 @@ public void BPTree_AccuracyTest()
                 var theoreticalMaxHeight = Math.Ceiling(Math.Log((i + 2) / 2, (int)Math.Ceiling((double)order / 2))) + 1;
 
                 Assert.IsTrue(actualMaxHeight <= theoreticalMaxHeight);
+
                 Assert.IsTrue(tree.Count == i + 1);
+                Assert.AreEqual(i + 1, tree.Count());
+                Assert.AreEqual(i + 1, tree.Distinct().Count());
+                Assert.AreEqual(i + 1, tree.AsEnumerableDesc().Count());
+                Assert.AreEqual(i + 1, tree.AsEnumerableDesc().Distinct().Count());
+                Assert.IsTrue(tree.AsEnumerable().OrderByDescending(x => x).SequenceEqual(tree.AsEnumerableDesc()));
 
                 Assert.IsTrue(tree.HasItem(randomNumbers[i]));
             }
@@ -119,12 +125,20 @@ public void BPTree_AccuracyTest()
             //check that the elements are in sorted order
             //since B+ tree stores all elements in leaves in sorted order from left to right
             int j = 1;
-            foreach(var element in tree)
+            foreach (var element in tree)
             {
                 Assert.AreEqual(j, element);
                 j++;
             }
 
+            j = nodeCount;
+            foreach (var element in tree.AsEnumerableDesc())
+            {
+                Assert.AreEqual(j, element);
+                j--;
+            }
+
+
             //shuffle again before deletion tests
             randomNumbers = Enumerable.Range(1, nodeCount)
                             .OrderBy(x => rnd.Next())
@@ -145,7 +159,13 @@ public void BPTree_AccuracyTest()
                 var theoreticalMaxHeight = i == nodeCount - 1 ? 0 : Math.Ceiling(Math.Log((nodeCount - i - 1 + 1) / 2, (int)Math.Ceiling((double)order / 2))) + 1;
 
                 Assert.IsTrue(actualMaxHeight <= theoreticalMaxHeight);
+
                 Assert.IsTrue(tree.Count == nodeCount - 1 - i);
+                Assert.AreEqual(nodeCount - 1 - i, tree.Count());
+                Assert.AreEqual(nodeCount - 1 - i, tree.Distinct().Count());
+                Assert.AreEqual(nodeCount - 1 - i, tree.AsEnumerableDesc().Count());
+                Assert.AreEqual(nodeCount - 1 - i, tree.AsEnumerableDesc().Distinct().Count());
+                Assert.IsTrue(tree.AsEnumerable().OrderByDescending(x => x).SequenceEqual(tree.AsEnumerableDesc()));
             }
 
             Assert.IsTrue(BTreeTester.GetMaxHeight(tree.Root) == 0);