Merge pull request #26 from justcoding121/master

justcoding121 · web-flow · commit ea64e7ac9c28 · 2018-11-09T12:40:26.000-05:00
Beta
diff --git a/docs/api/Advanced.Algorithms.DataStructures.BpTree-1.html b/docs/api/Advanced.Algorithms.DataStructures.BpTree-1.html
@@ -122,7 +122,7 @@ <h4 id="Advanced_Algorithms_DataStructures_BpTree_1__ctor_System_Int32_" data-ui
   <div class="markdown level1 conceptual"></div>
   <h5 class="decalaration">Declaration</h5>
   <div class="codewrapper">
-    <pre><code class="lang-csharp hljs">public BpTree(int maxKeysPerNode)</code></pre>
+    <pre><code class="lang-csharp hljs">public BpTree(int maxKeysPerNode = 3)</code></pre>
   </div>
   <h5 class="parameters">Parameters</h5>
   <table class="table table-bordered table-striped table-condensed">
@@ -172,7 +172,7 @@ <h5 class="propertyValue">Property Value</h5>
   
   <a id="Advanced_Algorithms_DataStructures_BpTree_1_Max_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.Max*"></a>
   <h4 id="Advanced_Algorithms_DataStructures_BpTree_1_Max" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.Max">Max</h4>
-  <div class="markdown level1 summary"><p>Time complexity: O(log(n)).</p>
+  <div class="markdown level1 summary"><p>Time complexity: O(1).</p>
 </div>
   <div class="markdown level1 conceptual"></div>
   <h5 class="decalaration">Declaration</h5>
@@ -224,6 +224,32 @@ <h3 id="methods">Methods
   </h3>
   
   
+  <a id="Advanced_Algorithms_DataStructures_BpTree_1_AsEnumerableDesc_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc*"></a>
+  <h4 id="Advanced_Algorithms_DataStructures_BpTree_1_AsEnumerableDesc" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc">AsEnumerableDesc()</h4>
+  <div class="markdown level1 summary"><p>Descending enumerable.</p>
+</div>
+  <div class="markdown level1 conceptual"></div>
+  <h5 class="decalaration">Declaration</h5>
+  <div class="codewrapper">
+    <pre><code class="lang-csharp hljs">public IEnumerable&lt;T&gt; AsEnumerableDesc()</code></pre>
+  </div>
+  <h5 class="returns">Returns</h5>
+  <table class="table table-bordered table-striped table-condensed">
+    <thead>
+      <tr>
+        <th>Type</th>
+        <th>Description</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td><span class="xref">IEnumerable</span>&lt;T&gt;</td>
+        <td></td>
+      </tr>
+    </tbody>
+  </table>
+  
+  
   <a id="Advanced_Algorithms_DataStructures_BpTree_1_Delete_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.Delete*"></a>
   <h4 id="Advanced_Algorithms_DataStructures_BpTree_1_Delete__0_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.Delete(`0)">Delete(T)</h4>
   <div class="markdown level1 summary"><p>Time complexity: O(log(n)).</p>
@@ -277,6 +303,31 @@ <h5 class="returns">Returns</h5>
   </table>
   
   
+  <a id="Advanced_Algorithms_DataStructures_BpTree_1_GetEnumeratorDesc_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc*"></a>
+  <h4 id="Advanced_Algorithms_DataStructures_BpTree_1_GetEnumeratorDesc" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc">GetEnumeratorDesc()</h4>
+  <div class="markdown level1 summary"></div>
+  <div class="markdown level1 conceptual"></div>
+  <h5 class="decalaration">Declaration</h5>
+  <div class="codewrapper">
+    <pre><code class="lang-csharp hljs">public IEnumerator&lt;T&gt; GetEnumeratorDesc()</code></pre>
+  </div>
+  <h5 class="returns">Returns</h5>
+  <table class="table table-bordered table-striped table-condensed">
+    <thead>
+      <tr>
+        <th>Type</th>
+        <th>Description</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td><span class="xref">IEnumerator</span>&lt;T&gt;</td>
+        <td></td>
+      </tr>
+    </tbody>
+  </table>
+  
+  
   <a id="Advanced_Algorithms_DataStructures_BpTree_1_HasItem_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.HasItem*"></a>
   <h4 id="Advanced_Algorithms_DataStructures_BpTree_1_HasItem__0_" data-uid="Advanced.Algorithms.DataStructures.BpTree`1.HasItem(`0)">HasItem(T)</h4>
   <div class="markdown level1 summary"><p>Time complexity: O(log(n)).</p>
diff --git a/docs/index.json b/docs/index.json
@@ -77,7 +77,7 @@
   "api/Advanced.Algorithms.DataStructures.BpTree-1.html": {
     "href": "api/Advanced.Algorithms.DataStructures.BpTree-1.html",
     "title": "Class BpTree<T> | Advanced Algorithms",
-    "keywords": "Class BpTree<T> A B+ tree implementation. Inheritance Object BpTree<T> Namespace : Advanced.Algorithms.DataStructures Assembly : Advanced.Algorithms.dll Syntax public class BpTree<T> : IEnumerable<T> where T : IComparable Type Parameters Name Description T Constructors BpTree(Int32) Declaration public BpTree(int maxKeysPerNode) Parameters Type Name Description Int32 maxKeysPerNode Properties Count Declaration public int Count { get; } Property Value Type Description Int32 Max Time complexity: O(log(n)). Declaration public T Max { get; } Property Value Type Description T Min Time complexity: O(1). Declaration public T Min { get; } Property Value Type Description T Methods Delete(T) Time complexity: O(log(n)). Declaration public void Delete(T value) Parameters Type Name Description T value GetEnumerator() Declaration public IEnumerator<T> GetEnumerator() Returns Type Description IEnumerator <T> HasItem(T) Time complexity: O(log(n)). Declaration public bool HasItem(T value) Parameters Type Name Description T value Returns Type Description Boolean Insert(T) Time complexity: O(log(n)). Declaration public void Insert(T newValue) Parameters Type Name Description T newValue"
+    "keywords": "Class BpTree<T> A B+ tree implementation. Inheritance Object BpTree<T> Namespace : Advanced.Algorithms.DataStructures Assembly : Advanced.Algorithms.dll Syntax public class BpTree<T> : IEnumerable<T> where T : IComparable Type Parameters Name Description T Constructors BpTree(Int32) Declaration public BpTree(int maxKeysPerNode = 3) Parameters Type Name Description Int32 maxKeysPerNode Properties Count Declaration public int Count { get; } Property Value Type Description Int32 Max Time complexity: O(1). Declaration public T Max { get; } Property Value Type Description T Min Time complexity: O(1). Declaration public T Min { get; } Property Value Type Description T Methods AsEnumerableDesc() Descending enumerable. Declaration public IEnumerable<T> AsEnumerableDesc() Returns Type Description IEnumerable <T> Delete(T) Time complexity: O(log(n)). Declaration public void Delete(T value) Parameters Type Name Description T value GetEnumerator() Declaration public IEnumerator<T> GetEnumerator() Returns Type Description IEnumerator <T> GetEnumeratorDesc() Declaration public IEnumerator<T> GetEnumeratorDesc() Returns Type Description IEnumerator <T> HasItem(T) Time complexity: O(log(n)). Declaration public bool HasItem(T value) Parameters Type Name Description T value Returns Type Description Boolean Insert(T) Time complexity: O(log(n)). Declaration public void Insert(T newValue) Parameters Type Name Description T newValue"
   },
   "api/Advanced.Algorithms.DataStructures.BST-1.html": {
     "href": "api/Advanced.Algorithms.DataStructures.BST-1.html",
diff --git a/docs/xrefmap.yml b/docs/xrefmap.yml
@@ -1010,6 +1010,23 @@ references:
   fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).BpTree
   nameWithType: BpTree<T>.BpTree
   nameWithType.vb: BpTree(Of T).BpTree
+- uid: Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc
+  name: AsEnumerableDesc()
+  href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_AsEnumerableDesc
+  commentId: M:Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc
+  fullName: Advanced.Algorithms.DataStructures.BpTree<T>.AsEnumerableDesc()
+  fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).AsEnumerableDesc()
+  nameWithType: BpTree<T>.AsEnumerableDesc()
+  nameWithType.vb: BpTree(Of T).AsEnumerableDesc()
+- uid: Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc*
+  name: AsEnumerableDesc
+  href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_AsEnumerableDesc_
+  commentId: Overload:Advanced.Algorithms.DataStructures.BpTree`1.AsEnumerableDesc
+  isSpec: "True"
+  fullName: Advanced.Algorithms.DataStructures.BpTree<T>.AsEnumerableDesc
+  fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).AsEnumerableDesc
+  nameWithType: BpTree<T>.AsEnumerableDesc
+  nameWithType.vb: BpTree(Of T).AsEnumerableDesc
 - uid: Advanced.Algorithms.DataStructures.BpTree`1.Count
   name: Count
   href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_Count
@@ -1061,6 +1078,23 @@ references:
   fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).GetEnumerator
   nameWithType: BpTree<T>.GetEnumerator
   nameWithType.vb: BpTree(Of T).GetEnumerator
+- uid: Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc
+  name: GetEnumeratorDesc()
+  href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_GetEnumeratorDesc
+  commentId: M:Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc
+  fullName: Advanced.Algorithms.DataStructures.BpTree<T>.GetEnumeratorDesc()
+  fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).GetEnumeratorDesc()
+  nameWithType: BpTree<T>.GetEnumeratorDesc()
+  nameWithType.vb: BpTree(Of T).GetEnumeratorDesc()
+- uid: Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc*
+  name: GetEnumeratorDesc
+  href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_GetEnumeratorDesc_
+  commentId: Overload:Advanced.Algorithms.DataStructures.BpTree`1.GetEnumeratorDesc
+  isSpec: "True"
+  fullName: Advanced.Algorithms.DataStructures.BpTree<T>.GetEnumeratorDesc
+  fullName.vb: Advanced.Algorithms.DataStructures.BpTree(Of T).GetEnumeratorDesc
+  nameWithType: BpTree<T>.GetEnumeratorDesc
+  nameWithType.vb: BpTree(Of T).GetEnumeratorDesc
 - uid: Advanced.Algorithms.DataStructures.BpTree`1.HasItem(`0)
   name: HasItem(T)
   href: api/Advanced.Algorithms.DataStructures.BpTree-1.html#Advanced_Algorithms_DataStructures_BpTree_1_HasItem__0_
diff --git a/src/Advanced.Algorithms/DataStructures/Heap/BHeap.cs b/src/Advanced.Algorithms/DataStructures/Heap/BHeap.cs
@@ -55,7 +55,7 @@ public BHeap(SortDirection sortDirection, IEnumerable<T> initial, IComparer<T> c
                     i++;
                 }
 
-                BulkInit(initArray);
+                bulkInit(initArray);
                 Count = initArray.Length;
             }
             else
@@ -64,7 +64,7 @@ public BHeap(SortDirection sortDirection, IEnumerable<T> initial, IComparer<T> c
             }
         }
 
-        private void BulkInit(T[] initial)
+        private void bulkInit(T[] initial)
         {
             var i = (initial.Length - 1) / 2;
 
@@ -86,7 +86,8 @@ private void bulkInitRecursive(int i, T[] initial)
                 var left = 2 * i + 1;
                 var right = 2 * i + 2;
 
-                var minMax = left < initial.Length && right < initial.Length ? comparer.Compare(initial[left], initial[right]) < 0 ? left : right
+                var minMax = left < initial.Length && right < initial.Length ? 
+                    comparer.Compare(initial[left], initial[right]) < 0 ? left : right
                     : left < initial.Length ? left
                     : right < initial.Length ? right : -1;
 
diff --git a/src/Advanced.Algorithms/DataStructures/Heap/d-aryHeap.cs b/src/Advanced.Algorithms/DataStructures/Heap/d-aryHeap.cs
@@ -47,7 +47,7 @@ public DaryHeap(int k, SortDirection sortDirection = SortDirection.Ascending, IE
                 }
 
                 Count = initArray.Length;
-                BulkInit(initArray);
+                bulkInit(initArray);
               
             }
             else
@@ -60,7 +60,7 @@ public DaryHeap(int k, SortDirection sortDirection = SortDirection.Ascending, IE
         /// Initialize with given input.
         /// Time complexity: O(n).
         /// </summary>
-        private void BulkInit(T[] initial)
+        private void bulkInit(T[] initial)
         {
             var i = (initial.Length - 1) / k;
 
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/B+Tree.cs b/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/Right Node
+        /// for fast ascending/descending enumeration using Next pointer.
+        /// See IEnumerable and 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;
         }
     }
 
diff --git a/tests/Advanced.Algorithms.Tests/DataStructures/Tree/B+Tree_Tests.cs b/tests/Advanced.Algorithms.Tests/DataStructures/Tree/B+Tree_Tests.cs

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public BHeap(SortDirection sortDirection, IEnumerable<T> initial, IComparer<T> c`
`55`	`55`	`i++;`
`56`	`56`	`}`
`57`	`57`
`58`		`- BulkInit(initArray);`
	`58`	`+ bulkInit(initArray);`
`59`	`59`	`Count = initArray.Length;`
`60`	`60`	`}`
`61`	`61`	`else`
`@@ -64,7 +64,7 @@ public BHeap(SortDirection sortDirection, IEnumerable<T> initial, IComparer<T> c`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`67`		`- private void BulkInit(T[] initial)`
	`67`	`+ private void bulkInit(T[] initial)`
`68`	`68`	`{`
`69`	`69`	`var i = (initial.Length - 1) / 2;`
`70`	`70`
`@@ -86,7 +86,8 @@ private void bulkInitRecursive(int i, T[] initial)`
`86`	`86`	`var left = 2 * i + 1;`
`87`	`87`	`var right = 2 * i + 2;`
`88`	`88`
`89`		`- var minMax = left < initial.Length && right < initial.Length ? comparer.Compare(initial[left], initial[right]) < 0 ? left : right`
	`89`	`+ var minMax = left < initial.Length && right < initial.Length ?`
	`90`	`+ comparer.Compare(initial[left], initial[right]) < 0 ? left : right`
`90`	`91`	`: left < initial.Length ? left`
`91`	`92`	`: right < initial.Length ? right : -1;`
`92`	`93`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public DaryHeap(int k, SortDirection sortDirection = SortDirection.Ascending, IE`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`Count = initArray.Length;`
`50`		`- BulkInit(initArray);`
	`50`	`+ bulkInit(initArray);`
`51`	`51`
`52`	`52`	`}`
`53`	`53`	`else`
`@@ -60,7 +60,7 @@ public DaryHeap(int k, SortDirection sortDirection = SortDirection.Ascending, IE`
`60`	`60`	`/// Initialize with given input.`
`61`	`61`	`/// Time complexity: O(n).`
`62`	`62`	`/// </summary>`
`63`		`- private void BulkInit(T[] initial)`
	`63`	`+ private void bulkInit(T[] initial)`
`64`	`64`	`{`
`65`	`65`	`var i = (initial.Length - 1) / k;`
`66`	`66`
Original file line number	Diff line number	Diff line change
`@@ -14,24 +14,26 @@ public class BpTree<T> : IEnumerable<T> where T : IComparable`
`14`	`14`	`internal BpTreeNode<T> Root;`
`15`	`15`
`16`	`16`	`/// <summary>`
`17`		`- ///Keep a reference of Bottom Left Node`
`18`		`- ///For faster enumeration with IEnumerable implementation using Next pointer`
	`17`	`+ /// Keep a reference of Bottom Left/Right Node`
	`18`	`+ /// for fast ascending/descending enumeration using Next pointer.`
	`19`	`+ /// See IEnumerable and IEnumerableDesc implementation at bottom.`
`19`	`20`	`/// </summary>`
`20`	`21`	`internal BpTreeNode<T> BottomLeftNode;`
	`22`	`+ internal BpTreeNode<T> BottomRightNode;`
`21`	`23`
`22`	`24`	`private readonly int maxKeysPerNode;`
`23`	`25`	`private readonly int minKeysPerNode;`
`24`	`26`
`25`	`27`	`/// <summary>`
`26`		`- /// Time complexity: O(log(n)).`
	`28`	`+ /// Time complexity: O(1).`
`27`	`29`	`/// </summary>`
`28`	`30`	`public T Max`
`29`	`31`	`{`
`30`	`32`	`get`
`31`	`33`	`{`
`32`	`34`	`if (Root == null) return default(T);`
`33`	`35`
`34`		`- var maxNode = findMaxNode(Root);`
	`36`	`+ var maxNode = BottomRightNode;`
`35`	`37`	`return maxNode.Keys[maxNode.KeyCount - 1];`
`36`	`38`	`}`
`37`	`39`	`}`
`@@ -50,7 +52,7 @@ public T Min`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`
`53`		`- public BpTree(int maxKeysPerNode)`
	`55`	`+ public BpTree(int maxKeysPerNode = 3)`
`54`	`56`	`{`
`55`	`57`	`if (maxKeysPerNode < 3)`
`56`	`58`	`{`
`@@ -122,6 +124,7 @@ public void Insert(T newValue)`
`122`	`124`	`Root.KeyCount++;`
`123`	`125`	`Count++;`
`124`	`126`	`BottomLeftNode = Root;`
	`127`	`+ BottomRightNode = Root;`
`125`	`128`	`return;`
`126`	`129`	`}`
`127`	`130`
`@@ -204,6 +207,11 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,`
`204`	`207`	`right.Next = node.Next;`
`205`	`208`	`node.Next.Prev = right;`
`206`	`209`	`}`
	`210`	`+ else`
	`211`	`+ {`
	`212`	`+ //bottom right most node`
	`213`	`+ BottomRightNode = right;`
	`214`	`+ }`
`207`	`215`
`208`	`216`	`if (node.Prev != null)`
`209`	`217`	`{`
`@@ -212,7 +220,7 @@ private void insertAndSplit(ref BpTreeNode<T> node, T newValue,`
`212`	`220`	`}`
`213`	`221`	`else`
`214`	`222`	`{`
`215`		`- //left most bottom node`
	`223`	`+ //bottom left most node`
`216`	`224`	`BottomLeftNode = left;`
`217`	`225`	`}`
`218`	`226`	`}`
`@@ -559,7 +567,10 @@ private void sandwich(BpTreeNode<T> leftSibling, BpTreeNode<T> rightSibling, T d`
`559`	`567`	`newNode.Next = rightSibling.Next;`
`560`	`568`	`rightSibling.Next.Prev = newNode;`
`561`	`569`	`}`
`562`		`-`
	`570`	`+ else`
	`571`	`+ {`
	`572`	`+ BottomRightNode = newNode;`
	`573`	`+ }`
`563`	`574`	`}`
`564`	`575`
`565`	`576`	`var newIndex = 0;`
`@@ -912,6 +923,14 @@ private void removeAt<TS>(TS[] array, int index)`
`912`	`923`	`Array.Copy(array, index + 1, array, index, array.Length - index - 1);`
`913`	`924`	`}`
`914`	`925`
	`926`	`+ /// <summary>`
	`927`	`+ /// Descending enumerable.`
	`928`	`+ /// </summary>`
	`929`	`+ public IEnumerable<T> AsEnumerableDesc()`
	`930`	`+ {`
	`931`	`+ return GetEnumeratorDesc().AsEnumerable();`
	`932`	`+ }`
	`933`	`+`
`915`	`934`	`//Implementation for the GetEnumerator method.`
`916`	`935`	`IEnumerator IEnumerable.GetEnumerator()`
`917`	`936`	`{`
`@@ -922,6 +941,11 @@ public IEnumerator<T> GetEnumerator()`
`922`	`941`	`{`
`923`	`942`	`return new BpTreeEnumerator<T>(this);`
`924`	`943`	`}`
	`944`	`+`
	`945`	`+ public IEnumerator<T> GetEnumeratorDesc()`
	`946`	`+ {`
	`947`	`+ return new BpTreeEnumerator<T>(this, false);`
	`948`	`+ }`
`925`	`949`	`}`
`926`	`950`
`927`	`951`	`internal class BpTreeNode<T> : BNode<T> where T : IComparable`
`@@ -970,14 +994,21 @@ internal override BNode<T>[] GetChildren()`
`970`	`994`
`971`	`995`	`internal class BpTreeEnumerator<T> : IEnumerator<T> where T : IComparable`
`972`	`996`	`{`
`973`		`- private BpTreeNode<T> bottomLeftNode;`
	`997`	`+ private readonly bool asc;`
	`998`	`+`
	`999`	`+ private BpTreeNode<T> startNode;`
`974`	`1000`	`private BpTreeNode<T> current;`
`975`		`- private int index = -1;`
`976`	`1001`
`977`		`- internal BpTreeEnumerator(BpTree<T> tree)`
	`1002`	`+ private int index;`
	`1003`	`+`
	`1004`	`+ internal BpTreeEnumerator(BpTree<T> tree, bool asc = true)`
`978`	`1005`	`{`
`979`		`- bottomLeftNode = tree.BottomLeftNode;`
`980`		`- current = bottomLeftNode;`
	`1006`	`+ this.asc = asc;`
	`1007`	`+`
	`1008`	`+ startNode = asc ? tree.BottomLeftNode : tree.BottomRightNode;`
	`1009`	`+ current = startNode;`
	`1010`	`+`
	`1011`	`+ index = asc ? -1 : current.KeyCount;`
`981`	`1012`	`}`
`982`	`1013`
`983`	`1014`	`public bool MoveNext()`
`@@ -987,22 +1018,38 @@ public bool MoveNext()`
`987`	`1018`	`return false;`
`988`	`1019`	`}`
`989`	`1020`
`990`		`- if (index + 1 < current.KeyCount)`
	`1021`	`+ if (asc)`
`991`	`1022`	`{`
`992`		`- index++;`
`993`		`- return true;`
	`1023`	`+ if (index + 1 < current.KeyCount)`
	`1024`	`+ {`
	`1025`	`+ index++;`
	`1026`	`+ return true;`
	`1027`	`+ }`
	`1028`	`+ }`
	`1029`	`+ else`
	`1030`	`+ {`
	`1031`	`+ if (index - 1 >= 0)`
	`1032`	`+ {`
	`1033`	`+ index--;`
	`1034`	`+ return true;`
	`1035`	`+ }`
`994`	`1036`	`}`
`995`	`1037`
`996`		`- current = current.Next;`
`997`		`- index = 0;`
	`1038`	`+ current = asc ? current.Next : current.Prev;`
	`1039`	`+`
	`1040`	`+ var canMove = current != null && current.KeyCount > 0;`
	`1041`	`+ if (canMove)`
	`1042`	`+ {`
	`1043`	`+ index = asc ? 0 : current.KeyCount - 1;`
	`1044`	`+ }`
`998`	`1045`
`999`		`- return current != null && current.KeyCount > 0;`
	`1046`	`+ return canMove;`
`1000`	`1047`	`}`
`1001`	`1048`
`1002`	`1049`	`public void Reset()`
`1003`	`1050`	`{`
`1004`		`- current = bottomLeftNode;`
`1005`		`- index = -1;`
	`1051`	`+ current = startNode;`
	`1052`	`+ index = asc ? -1 : current.KeyCount;`
`1006`	`1053`	`}`
`1007`	`1054`
`1008`	`1055`	`object IEnumerator.Current => Current;`
`@@ -1018,8 +1065,7 @@ public T Current`
`1018`	`1065`	`public void Dispose()`
`1019`	`1066`	`{`
`1020`	`1067`	`current = null;`
`1021`		`- bottomLeftNode = null;`
`1022`		`- index = -1;`
	`1068`	`+ startNode = null;`
`1023`	`1069`	`}`
`1024`	`1070`	`}`
`1025`	`1071`