From e1822e71fc1d548488fcacaa8983031fefc7ec4e Mon Sep 17 00:00:00 2001
From: ethanhaines <122860615+ethanhaines@users.noreply.github.com>
Date: Mon, 3 Nov 2025 17:27:07 -0500
Subject: [PATCH 1/3] Added BTree Data Structure and Tests

---
 DataStructures.Tests/BTreeTests.cs | 567 ++++++++++++++++++++++
 DataStructures/BTree/BTree.cs      | 742 +++++++++++++++++++++++++++++
 DataStructures/BTree/BTreeNode.cs  | 105 ++++
 README.md                          |   3 +
 4 files changed, 1417 insertions(+)
 create mode 100644 DataStructures.Tests/BTreeTests.cs
 create mode 100644 DataStructures/BTree/BTree.cs
 create mode 100644 DataStructures/BTree/BTreeNode.cs

diff --git a/DataStructures.Tests/BTreeTests.cs b/DataStructures.Tests/BTreeTests.cs
new file mode 100644
index 00000000..ab201bce
--- /dev/null
+++ b/DataStructures.Tests/BTreeTests.cs
@@ -0,0 +1,567 @@
+using DataStructures.BTree;
+using static FluentAssertions.FluentActions;
+
+namespace DataStructures.Tests;
+
+internal class BTreeTests
+{
+    private static readonly int[] Data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+
+    [Test]
+    public void Constructor_DefaultMinimumDegree_CreatesEmptyTree()
+    {
+        var tree = new BTree<int>();
+
+        tree.Count.Should().Be(0);
+        tree.MinimumDegree.Should().Be(2);
+    }
+
+    [Test]
+    public void Constructor_CustomMinimumDegree_SetsCorrectDegree()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.MinimumDegree.Should().Be(3);
+        tree.Count.Should().Be(0);
+    }
+
+    [Test]
+    public void Constructor_MinimumDegreeLessThan2_ThrowsException()
+    {
+        Invoking(() => new BTree<int>(1))
+            .Should()
+            .ThrowExactly<ArgumentException>()
+            .WithMessage("Minimum degree must be at least 2.*");
+    }
+
+    [Test]
+    public void Constructor_UseCustomComparer_FormsCorrectTree()
+    {
+        var tree = new BTree<int>(2, Comparer<int>.Create((x, y) => y.CompareTo(x)));
+
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+
+        tree.GetMin().Should().Be(5);
+        tree.GetMax().Should().Be(1);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 5, 4, 3, 2, 1 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Add_SingleKey_IncreasesCount()
+    {
+        var tree = new BTree<int>();
+
+        tree.Add(5);
+
+        tree.Count.Should().Be(1);
+        tree.Contains(5).Should().BeTrue();
+    }
+
+    [Test]
+    public void Add_MultipleKeys_FormsCorrectTree()
+    {
+        var tree = new BTree<int>(2);
+
+        for (var i = 0; i < Data.Length; i++)
+        {
+            tree.Add(Data[i]);
+            tree.Count.Should().Be(i + 1);
+        }
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                Data,
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Add_DuplicateKey_ThrowsException()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+
+        Invoking(() => tree.Add(3))
+            .Should()
+            .ThrowExactly<ArgumentException>()
+            .WithMessage("""Key "3" already exists in B-Tree.""");
+    }
+
+    [Test]
+    public void Add_CausesNodeSplit_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });
+
+        tree.Count.Should().Be(7);
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 5, 6, 7 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Add_LargeNumberOfKeys_TreeStillValid()
+    {
+        var tree = new BTree<int>(3);
+        var keys = Enumerable.Range(1, 100).ToArray();
+
+        tree.AddRange(keys);
+
+        tree.Count.Should().Be(100);
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                keys,
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void AddRange_MultipleKeys_FormsCorrectTree()
+    {
+        var tree = new BTree<char>(2);
+        tree.AddRange(new[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' });
+
+        tree.Count.Should().Be(7);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void AddRange_EmptyCollection_TreeRemainsEmpty()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(Array.Empty<int>());
+
+        tree.Count.Should().Be(0);
+        tree.GetKeysInOrder().Should().BeEmpty();
+    }
+
+    [Test]
+    public void Contains_KeyExists_ReturnsTrue()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(Data);
+
+        tree.Contains(5).Should().BeTrue();
+        tree.Contains(1).Should().BeTrue();
+        tree.Contains(15).Should().BeTrue();
+    }
+
+    [Test]
+    public void Contains_KeyDoesNotExist_ReturnsFalse()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(Data);
+
+        tree.Contains(100).Should().BeFalse();
+        tree.Contains(-5).Should().BeFalse();
+        tree.Contains(0).Should().BeFalse();
+    }
+
+    [Test]
+    public void Contains_EmptyTree_ReturnsFalse()
+    {
+        var tree = new BTree<int>();
+
+        tree.Contains(5).Should().BeFalse();
+        tree.Contains(-12).Should().BeFalse();
+    }
+
+    [Test]
+    public void Remove_SingleKey_DecreasesCount()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+
+        tree.Remove(3);
+
+        tree.Count.Should().Be(4);
+        tree.Contains(3).Should().BeFalse();
+    }
+
+    [Test]
+    public void Remove_FromLeafNode_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(Data);
+
+        tree.Remove(1);
+
+        tree.Count.Should().Be(14);
+        tree.Contains(1).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_FromNonLeafNode_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(Data);
+
+        tree.Remove(8);
+
+        tree.Count.Should().Be(14);
+        tree.Contains(8).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_CausesMerge_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });
+
+        tree.Remove(4);
+
+        tree.Count.Should().Be(6);
+        tree.Contains(4).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 5, 6, 7 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_MultipleKeys_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(Data);
+
+        tree.Remove(5);
+        tree.Remove(10);
+        tree.Remove(15);
+
+        tree.Count.Should().Be(12);
+        tree.Contains(5).Should().BeFalse();
+        tree.Contains(10).Should().BeFalse();
+        tree.Contains(15).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_AllKeys_TreeBecomesEmpty()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+
+        tree.Remove(1);
+        tree.Remove(2);
+        tree.Remove(3);
+        tree.Remove(4);
+        tree.Remove(5);
+
+        tree.Count.Should().Be(0);
+        tree.GetKeysInOrder().Should().BeEmpty();
+    }
+
+    [Test]
+    public void Remove_EmptyTree_ThrowsException()
+    {
+        var tree = new BTree<int>();
+
+        Invoking(() => tree.Remove(1))
+            .Should()
+            .ThrowExactly<KeyNotFoundException>()
+            .WithMessage("""Key "1" is not in the B-Tree.""");
+    }
+
+    [Test]
+    public void Remove_KeyNotInTree_ThrowsException()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(Data);
+
+        Invoking(() => tree.Remove(100))
+            .Should()
+            .ThrowExactly<KeyNotFoundException>()
+            .WithMessage("""Key "100" is not in the B-Tree.""");
+    }
+
+    [Test]
+    public void GetMin_NonEmptyTree_ReturnsMinimum()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(new[] { 5, 2, 8, 1, 9, 3 });
+
+        tree.GetMin().Should().Be(1);
+    }
+
+    [Test]
+    public void GetMin_SingleElement_ReturnsElement()
+    {
+        var tree = new BTree<int>();
+        tree.Add(42);
+
+        tree.GetMin().Should().Be(42);
+    }
+
+    [Test]
+    public void GetMin_EmptyTree_ThrowsException()
+    {
+        var tree = new BTree<int>();
+
+        Invoking(() => tree.GetMin())
+            .Should()
+            .ThrowExactly<InvalidOperationException>()
+            .WithMessage("B-Tree is empty.");
+    }
+
+    [Test]
+    public void GetMax_NonEmptyTree_ReturnsMaximum()
+    {
+        var tree = new BTree<int>();
+        tree.AddRange(new[] { 5, 2, 8, 1, 9, 3 });
+
+        tree.GetMax().Should().Be(9);
+    }
+
+    [Test]
+    public void GetMax_SingleElement_ReturnsElement()
+    {
+        var tree = new BTree<int>();
+        tree.Add(42);
+
+        tree.GetMax().Should().Be(42);
+    }
+
+    [Test]
+    public void GetMax_EmptyTree_ThrowsException()
+    {
+        var tree = new BTree<int>();
+
+        Invoking(() => tree.GetMax())
+            .Should()
+            .ThrowExactly<InvalidOperationException>()
+            .WithMessage("B-Tree is empty.");
+    }
+
+    [Test]
+    public void GetKeysInOrder_NonEmptyTree_ReturnsCorrectOrder()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 5, 2, 8, 1, 9, 3, 7, 4, 6 });
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void GetKeysInOrder_EmptyTree_ReturnsEmpty()
+    {
+        var tree = new BTree<int>();
+
+        tree.GetKeysInOrder().Should().BeEmpty();
+    }
+
+    [Test]
+    public void GetKeysInOrder_AfterRemoval_ReturnsCorrectOrder()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(Data);
+        tree.Remove(5);
+        tree.Remove(10);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void GetKeysPreOrder_NonEmptyTree_ReturnsCorrectOrder()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });
+
+        var preOrder = tree.GetKeysPreOrder().ToArray();
+
+        preOrder.Should().HaveCount(7);
+        preOrder.Should().Contain(new[] { 1, 2, 3, 4, 5, 6, 7 });
+    }
+
+    [Test]
+    public void GetKeysPreOrder_EmptyTree_ReturnsEmpty()
+    {
+        var tree = new BTree<int>();
+
+        tree.GetKeysPreOrder().Should().BeEmpty();
+    }
+
+    [Test]
+    public void GetKeysPostOrder_NonEmptyTree_ReturnsCorrectOrder()
+    {
+        var tree = new BTree<int>(2);
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });
+
+        var postOrder = tree.GetKeysPostOrder().ToArray();
+
+        postOrder.Should().HaveCount(7);
+        postOrder.Should().Contain(new[] { 1, 2, 3, 4, 5, 6, 7 });
+    }
+
+    [Test]
+    public void GetKeysPostOrder_EmptyTree_ReturnsEmpty()
+    {
+        var tree = new BTree<int>();
+
+        tree.GetKeysPostOrder().Should().BeEmpty();
+    }
+
+    [Test]
+    public void BTree_LargeDataSet_MaintainsCorrectness()
+    {
+        var tree = new BTree<int>(5);
+        var keys = Enumerable.Range(1, 1000).ToArray();
+
+        tree.AddRange(keys);
+
+        tree.Count.Should().Be(1000);
+        tree.GetMin().Should().Be(1);
+        tree.GetMax().Should().Be(1000);
+
+        var inOrder = tree.GetKeysInOrder().ToArray();
+        inOrder.Should().BeEquivalentTo(keys, config => config.WithStrictOrdering());
+
+        for (var i = 1; i <= 1000; i++)
+        {
+            tree.Contains(i).Should().BeTrue();
+        }
+    }
+
+    [Test]
+    public void BTree_RandomInsertion_MaintainsCorrectness()
+    {
+        var tree = new BTree<int>(3);
+        var random = new Random(42);
+        var keys = Enumerable.Range(1, 100)
+            .OrderBy(_ => random.Next())
+            .ToArray();
+
+        tree.AddRange(keys);
+
+        tree.Count.Should().Be(100);
+
+        var inOrder = tree.GetKeysInOrder().ToArray();
+        inOrder.Should().BeEquivalentTo(
+            Enumerable.Range(1, 100),
+            config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void BTree_RandomDeletion_MaintainsCorrectness()
+    {
+        var tree = new BTree<int>(3);
+        tree.AddRange(Enumerable.Range(1, 50));
+
+        var random = new Random(42);
+        var keysToRemove = Enumerable.Range(1, 50)
+            .OrderBy(_ => random.Next())
+            .Take(25)
+            .ToArray();
+
+        foreach (var key in keysToRemove)
+        {
+            tree.Remove(key);
+        }
+
+        tree.Count.Should().Be(25);
+
+        var remainingKeys = Enumerable.Range(1, 50)
+            .Except(keysToRemove)
+            .OrderBy(x => x)
+            .ToArray();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                remainingKeys,
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void BTree_StringKeys_WorksCorrectly()
+    {
+        var tree = new BTree<string>(2);
+        var keys = new[] { "apple", "banana", "cherry", "date", "elderberry", "fig", "grape" };
+
+        tree.AddRange(keys);
+
+        tree.Count.Should().Be(7);
+        tree.GetMin().Should().Be("apple");
+        tree.GetMax().Should().Be("grape");
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                keys.OrderBy(x => x),
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void BTree_DifferentMinimumDegrees_AllWorkCorrectly()
+    {
+        for (var degree = 2; degree <= 10; degree++)
+        {
+            var tree = new BTree<int>(degree);
+            tree.AddRange(Enumerable.Range(1, 50));
+
+            tree.Count.Should().Be(50);
+            tree.GetKeysInOrder()
+                .Should()
+                .BeEquivalentTo(
+                    Enumerable.Range(1, 50),
+                    config => config.WithStrictOrdering());
+        }
+    }
+
+    [Test]
+    public void BTree_InsertRemoveInsert_WorksCorrectly()
+    {
+        var tree = new BTree<int>(2);
+
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+        tree.Remove(3);
+        tree.Add(3);
+
+        tree.Count.Should().Be(5);
+        tree.Contains(3).Should().BeTrue();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 5 },
+                config => config.WithStrictOrdering());
+    }
+}
diff --git a/DataStructures/BTree/BTree.cs b/DataStructures/BTree/BTree.cs
new file mode 100644
index 00000000..5efdf227
--- /dev/null
+++ b/DataStructures/BTree/BTree.cs
@@ -0,0 +1,742 @@
+namespace DataStructures.BTree;
+
+/// <summary>
+///     A self-balancing search tree data structure that maintains sorted data
+///     and allows searches, sequential access, insertions, and deletions in
+///     logarithmic time.
+/// </summary>
+/// <remarks>
+///     A B-Tree is a generalization of a binary search tree in which a node
+///     can have more than two children. Unlike self-balancing binary search
+///     trees, the B-Tree is optimized for systems that read and write large
+///     blocks of data. It is commonly used in databases and file systems.
+///
+///     Properties of a B-Tree of minimum degree t:
+///     1. Every node has at most 2t-1 keys.
+///     2. Every node (except root) has at least t-1 keys.
+///     3. The root has at least 1 key (if tree is not empty).
+///     4. All leaves are at the same level.
+///     5. A non-leaf node with k keys has k+1 children.
+///
+///     Time Complexity:
+///     - Search: O(log n)
+///     - Insert: O(log n)
+///     - Delete: O(log n)
+///
+///     Space Complexity: O(n)
+///
+///     See https://en.wikipedia.org/wiki/B-tree for more information.
+///     Visualizer: https://www.cs.usfca.edu/~galles/visualization/BTree.html.
+/// </remarks>
+/// <typeparam name="TKey">Type of key for the tree.</typeparam>
+public class BTree<TKey>
+{
+    /// <summary>
+    ///     Gets the number of keys in the tree.
+    /// </summary>
+    public int Count { get; private set; }
+
+    /// <summary>
+    ///     Gets the minimum degree (t) of the B-Tree.
+    ///     Each node can contain at most 2t-1 keys and at least t-1 keys (except root).
+    /// </summary>
+    public int MinimumDegree { get; }
+
+    /// <summary>
+    ///     Comparer to use when comparing key values.
+    /// </summary>
+    private readonly Comparer<TKey> comparer;
+
+    /// <summary>
+    ///     Reference to the root node.
+    /// </summary>
+    private BTreeNode<TKey>? root;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="BTree{TKey}"/>
+    ///     class with the specified minimum degree.
+    /// </summary>
+    /// <param name="minimumDegree">
+    ///     Minimum degree (t) of the B-Tree. Must be at least 2.
+    ///     Each node can contain at most 2t-1 keys.
+    /// </param>
+    /// <exception cref="ArgumentException">
+    ///     Thrown when minimumDegree is less than 2.
+    /// </exception>
+    public BTree(int minimumDegree = 2)
+    {
+        if (minimumDegree < 2)
+        {
+            throw new ArgumentException("Minimum degree must be at least 2.", nameof(minimumDegree));
+        }
+
+        MinimumDegree = minimumDegree;
+        comparer = Comparer<TKey>.Default;
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="BTree{TKey}"/>
+    ///     class with the specified minimum degree and custom comparer.
+    /// </summary>
+    /// <param name="minimumDegree">
+    ///     Minimum degree (t) of the B-Tree. Must be at least 2.
+    /// </param>
+    /// <param name="customComparer">
+    ///     Comparer to use when comparing keys.
+    /// </param>
+    /// <exception cref="ArgumentException">
+    ///     Thrown when minimumDegree is less than 2.
+    /// </exception>
+    public BTree(int minimumDegree, Comparer<TKey> customComparer)
+    {
+        if (minimumDegree < 2)
+        {
+            throw new ArgumentException("Minimum degree must be at least 2.", nameof(minimumDegree));
+        }
+
+        MinimumDegree = minimumDegree;
+        comparer = customComparer;
+    }
+
+    /// <summary>
+    ///     Add a single key to the tree.
+    /// </summary>
+    /// <param name="key">Key value to add.</param>
+    public void Add(TKey key)
+    {
+        if (root is null)
+        {
+            root = new BTreeNode<TKey>(MinimumDegree, true);
+            root.InsertKey(0, key);
+            Count++;
+            return;
+        }
+
+        if (root.IsFull())
+        {
+            var newRoot = new BTreeNode<TKey>(MinimumDegree, false);
+            newRoot.InsertChild(0, root);
+            SplitChild(newRoot, 0);
+            root = newRoot;
+        }
+
+        InsertNonFull(root, key);
+        Count++;
+    }
+
+    /// <summary>
+    ///     Add multiple keys to the tree.
+    /// </summary>
+    /// <param name="keys">Key values to add.</param>
+    public void AddRange(IEnumerable<TKey> keys)
+    {
+        foreach (var key in keys)
+        {
+            Add(key);
+        }
+    }
+
+    /// <summary>
+    ///     Remove a key from the tree.
+    /// </summary>
+    /// <param name="key">Key value to remove.</param>
+    /// <exception cref="KeyNotFoundException">
+    ///     Thrown when the key is not found in the tree.
+    /// </exception>
+    public void Remove(TKey key)
+    {
+        if (root is null)
+        {
+            throw new KeyNotFoundException($"""Key "{key}" is not in the B-Tree.""");
+        }
+
+        Remove(root, key);
+
+        if (root.KeyCount == 0)
+        {
+            root = root.IsLeaf ? null : root.Children[0];
+        }
+
+        Count--;
+    }
+
+    /// <summary>
+    ///     Check if given key is in the tree.
+    /// </summary>
+    /// <param name="key">Key value to search for.</param>
+    /// <returns>Whether or not the key is in the tree.</returns>
+    public bool Contains(TKey key)
+    {
+        return Search(root, key) is not null;
+    }
+
+    /// <summary>
+    ///     Get the minimum key in the tree.
+    /// </summary>
+    /// <returns>Minimum key in tree.</returns>
+    /// <exception cref="InvalidOperationException">
+    ///     Thrown when the tree is empty.
+    /// </exception>
+    public TKey GetMin()
+    {
+        if (root is null)
+        {
+            throw new InvalidOperationException("B-Tree is empty.");
+        }
+
+        return GetMin(root);
+    }
+
+    /// <summary>
+    ///     Get the maximum key in the tree.
+    /// </summary>
+    /// <returns>Maximum key in tree.</returns>
+    /// <exception cref="InvalidOperationException">
+    ///     Thrown when the tree is empty.
+    /// </exception>
+    public TKey GetMax()
+    {
+        if (root is null)
+        {
+            throw new InvalidOperationException("B-Tree is empty.");
+        }
+
+        return GetMax(root);
+    }
+
+    /// <summary>
+    ///     Get keys in order from smallest to largest as defined by the
+    ///     comparer.
+    /// </summary>
+    /// <returns>Keys in tree in order from smallest to largest.</returns>
+    public IEnumerable<TKey> GetKeysInOrder()
+    {
+        List<TKey> result = [];
+        InOrderTraversal(root);
+        return result;
+
+        void InOrderTraversal(BTreeNode<TKey>? node)
+        {
+            if (node is null)
+            {
+                return;
+            }
+
+            for (var i = 0; i < node.KeyCount; i++)
+            {
+                if (!node.IsLeaf)
+                {
+                    InOrderTraversal(node.Children[i]);
+                }
+
+                result.Add(node.Keys[i]);
+            }
+
+            if (!node.IsLeaf)
+            {
+                InOrderTraversal(node.Children[node.KeyCount]);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Get keys in the pre-order order.
+    /// </summary>
+    /// <returns>Keys in pre-order order.</returns>
+    public IEnumerable<TKey> GetKeysPreOrder()
+    {
+        var result = new List<TKey>();
+        PreOrderTraversal(root);
+        return result;
+
+        void PreOrderTraversal(BTreeNode<TKey>? node)
+        {
+            if (node is null)
+            {
+                return;
+            }
+
+            for (var i = 0; i < node.KeyCount; i++)
+            {
+                result.Add(node.Keys[i]);
+            }
+
+            if (!node.IsLeaf)
+            {
+                for (var i = 0; i <= node.KeyCount; i++)
+                {
+                    PreOrderTraversal(node.Children[i]);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Get keys in the post-order order.
+    /// </summary>
+    /// <returns>Keys in the post-order order.</returns>
+    public IEnumerable<TKey> GetKeysPostOrder()
+    {
+        var result = new List<TKey>();
+        PostOrderTraversal(root);
+        return result;
+
+        void PostOrderTraversal(BTreeNode<TKey>? node)
+        {
+            if (node is null)
+            {
+                return;
+            }
+
+            if (!node.IsLeaf)
+            {
+                for (var i = 0; i <= node.KeyCount; i++)
+                {
+                    PostOrderTraversal(node.Children[i]);
+                }
+            }
+
+            for (var i = 0; i < node.KeyCount; i++)
+            {
+                result.Add(node.Keys[i]);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Search for a key in the subtree rooted at the given node.
+    /// </summary>
+    /// <param name="node">Root of the subtree to search.</param>
+    /// <param name="key">Key to search for.</param>
+    /// <returns>Node containing the key, or null if not found.</returns>
+    private BTreeNode<TKey>? Search(BTreeNode<TKey>? node, TKey key)
+    {
+        if (node is null)
+        {
+            return null;
+        }
+
+        var i = 0;
+        while (i < node.KeyCount && comparer.Compare(key, node.Keys[i]) > 0)
+        {
+            i++;
+        }
+
+        if (i < node.KeyCount && comparer.Compare(key, node.Keys[i]) == 0)
+        {
+            return node;
+        }
+
+        if (node.IsLeaf)
+        {
+            return null;
+        }
+
+        return Search(node.Children[i], key);
+    }
+
+    /// <summary>
+    ///     Insert a key into a non-full node.
+    /// </summary>
+    /// <param name="node">Node to insert the key into.</param>
+    /// <param name="key">Key to insert.</param>
+    /// <exception cref="ArgumentException">
+    ///     Thrown when the key already exists in the tree.
+    /// </exception>
+    private void InsertNonFull(BTreeNode<TKey> node, TKey key)
+    {
+        var i = node.KeyCount - 1;
+
+        if (node.IsLeaf)
+        {
+            while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
+            {
+                node.Keys[i + 1] = node.Keys[i];
+                i--;
+            }
+
+            if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
+            {
+                throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
+            }
+
+            node.Keys[i + 1] = key;
+            node.KeyCount++;
+        }
+        else
+        {
+            while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
+            {
+                i--;
+            }
+
+            if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
+            {
+                throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
+            }
+
+            i++;
+
+            if (node.Children[i]!.IsFull())
+            {
+                SplitChild(node, i);
+
+                if (comparer.Compare(key, node.Keys[i]) > 0)
+                {
+                    i++;
+                }
+            }
+
+            InsertNonFull(node.Children[i]!, key);
+        }
+    }
+
+    /// <summary>
+    ///     Split a full child of a node.
+    /// </summary>
+    /// <param name="parent">Parent node.</param>
+    /// <param name="childIndex">Index of the child to split.</param>
+    private void SplitChild(BTreeNode<TKey> parent, int childIndex)
+    {
+        var fullChild = parent.Children[childIndex]!;
+        var newChild = new BTreeNode<TKey>(MinimumDegree, fullChild.IsLeaf);
+        var midIndex = MinimumDegree - 1;
+
+        for (var j = 0; j < MinimumDegree - 1; j++)
+        {
+            newChild.Keys[j] = fullChild.Keys[j + MinimumDegree];
+            newChild.KeyCount++;
+        }
+
+        if (!fullChild.IsLeaf)
+        {
+            for (var j = 0; j < MinimumDegree; j++)
+            {
+                newChild.Children[j] = fullChild.Children[j + MinimumDegree];
+            }
+        }
+
+        fullChild.KeyCount = MinimumDegree - 1;
+
+        for (var j = parent.KeyCount; j > childIndex; j--)
+        {
+            parent.Children[j + 1] = parent.Children[j];
+        }
+
+        parent.Children[childIndex + 1] = newChild;
+
+        for (var j = parent.KeyCount - 1; j >= childIndex; j--)
+        {
+            parent.Keys[j + 1] = parent.Keys[j];
+        }
+
+        parent.Keys[childIndex] = fullChild.Keys[midIndex];
+        parent.KeyCount++;
+    }
+
+    /// <summary>
+    ///     Remove a key from the subtree rooted at the given node.
+    /// </summary>
+    /// <param name="node">Root of the subtree.</param>
+    /// <param name="key">Key to remove.</param>
+    /// <exception cref="KeyNotFoundException">
+    ///     Thrown when the key is not found in the subtree.
+    /// </exception>
+    private void Remove(BTreeNode<TKey> node, TKey key)
+    {
+        var idx = FindKey(node, key);
+
+        if (idx < node.KeyCount && comparer.Compare(node.Keys[idx], key) == 0)
+        {
+            if (node.IsLeaf)
+            {
+                RemoveFromLeaf(node, idx);
+            }
+            else
+            {
+                RemoveFromNonLeaf(node, idx);
+            }
+        }
+        else
+        {
+            if (node.IsLeaf)
+            {
+                throw new KeyNotFoundException($"""Key "{key}" is not in the B-Tree.""");
+            }
+
+            var isInSubtree = idx == node.KeyCount;
+
+            if (node.Children[idx]!.KeyCount < MinimumDegree)
+            {
+                Fill(node, idx);
+            }
+
+            if (isInSubtree && idx > node.KeyCount)
+            {
+                Remove(node.Children[idx - 1]!, key);
+            }
+            else
+            {
+                Remove(node.Children[idx]!, key);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Find the index of the first key greater than or equal to the given key.
+    /// </summary>
+    /// <param name="node">Node to search in.</param>
+    /// <param name="key">Key to find.</param>
+    /// <returns>Index of the first key >= key.</returns>
+    private int FindKey(BTreeNode<TKey> node, TKey key)
+    {
+        var idx = 0;
+        while (idx < node.KeyCount && comparer.Compare(node.Keys[idx], key) < 0)
+        {
+            idx++;
+        }
+
+        return idx;
+    }
+
+    /// <summary>
+    ///     Remove a key from a leaf node.
+    /// </summary>
+    /// <param name="node">Leaf node to remove from.</param>
+    /// <param name="idx">Index of the key to remove.</param>
+    private void RemoveFromLeaf(BTreeNode<TKey> node, int idx)
+    {
+        node.RemoveKey(idx);
+    }
+
+    /// <summary>
+    ///     Remove a key from a non-leaf node.
+    /// </summary>
+    /// <param name="node">Non-leaf node to remove from.</param>
+    /// <param name="idx">Index of the key to remove.</param>
+    private void RemoveFromNonLeaf(BTreeNode<TKey> node, int idx)
+    {
+        var key = node.Keys[idx];
+
+        if (node.Children[idx]!.KeyCount >= MinimumDegree)
+        {
+            var predecessor = GetPredecessor(node, idx);
+            node.Keys[idx] = predecessor;
+            Remove(node.Children[idx]!, predecessor);
+        }
+        else if (node.Children[idx + 1]!.KeyCount >= MinimumDegree)
+        {
+            var successor = GetSuccessor(node, idx);
+            node.Keys[idx] = successor;
+            Remove(node.Children[idx + 1]!, successor);
+        }
+        else
+        {
+            Merge(node, idx);
+            Remove(node.Children[idx]!, key);
+        }
+    }
+
+    /// <summary>
+    ///     Get the predecessor key of the key at the given index.
+    /// </summary>
+    /// <param name="node">Node containing the key.</param>
+    /// <param name="idx">Index of the key.</param>
+    /// <returns>Predecessor key.</returns>
+    private TKey GetPredecessor(BTreeNode<TKey> node, int idx)
+    {
+        var current = node.Children[idx]!;
+        while (!current.IsLeaf)
+        {
+            current = current.Children[current.KeyCount]!;
+        }
+
+        return current.Keys[current.KeyCount - 1];
+    }
+
+    /// <summary>
+    ///     Get the successor key of the key at the given index.
+    /// </summary>
+    /// <param name="node">Node containing the key.</param>
+    /// <param name="idx">Index of the key.</param>
+    /// <returns>Successor key.</returns>
+    private TKey GetSuccessor(BTreeNode<TKey> node, int idx)
+    {
+        var current = node.Children[idx + 1]!;
+        while (!current.IsLeaf)
+        {
+            current = current.Children[0]!;
+        }
+
+        return current.Keys[0];
+    }
+
+    /// <summary>
+    ///     Fill a child node that has fewer than minimum degree - 1 keys.
+    /// </summary>
+    /// <param name="node">Parent node.</param>
+    /// <param name="idx">Index of the child to fill.</param>
+    private void Fill(BTreeNode<TKey> node, int idx)
+    {
+        if (idx != 0 && node.Children[idx - 1]!.KeyCount >= MinimumDegree)
+        {
+            BorrowFromPrevious(node, idx);
+        }
+        else if (idx != node.KeyCount && node.Children[idx + 1]!.KeyCount >= MinimumDegree)
+        {
+            BorrowFromNext(node, idx);
+        }
+        else
+        {
+            if (idx != node.KeyCount)
+            {
+                Merge(node, idx);
+            }
+            else
+            {
+                Merge(node, idx - 1);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Borrow a key from the previous sibling.
+    /// </summary>
+    /// <param name="node">Parent node.</param>
+    /// <param name="childIdx">Index of the child that needs a key.</param>
+    private void BorrowFromPrevious(BTreeNode<TKey> node, int childIdx)
+    {
+        var child = node.Children[childIdx]!;
+        var sibling = node.Children[childIdx - 1]!;
+
+        for (var i = child.KeyCount - 1; i >= 0; i--)
+        {
+            child.Keys[i + 1] = child.Keys[i];
+        }
+
+        if (!child.IsLeaf)
+        {
+            for (var i = child.KeyCount; i >= 0; i--)
+            {
+                child.Children[i + 1] = child.Children[i];
+            }
+        }
+
+        child.Keys[0] = node.Keys[childIdx - 1];
+
+        if (!child.IsLeaf)
+        {
+            child.Children[0] = sibling.Children[sibling.KeyCount];
+        }
+
+        node.Keys[childIdx - 1] = sibling.Keys[sibling.KeyCount - 1];
+
+        child.KeyCount++;
+        sibling.KeyCount--;
+    }
+
+    /// <summary>
+    ///     Borrow a key from the next sibling.
+    /// </summary>
+    /// <param name="node">Parent node.</param>
+    /// <param name="childIdx">Index of the child that needs a key.</param>
+    private void BorrowFromNext(BTreeNode<TKey> node, int childIdx)
+    {
+        var child = node.Children[childIdx]!;
+        var sibling = node.Children[childIdx + 1]!;
+
+        child.Keys[child.KeyCount] = node.Keys[childIdx];
+
+        if (!child.IsLeaf)
+        {
+            child.Children[child.KeyCount + 1] = sibling.Children[0];
+        }
+
+        node.Keys[childIdx] = sibling.Keys[0];
+
+        for (var i = 1; i < sibling.KeyCount; i++)
+        {
+            sibling.Keys[i - 1] = sibling.Keys[i];
+        }
+
+        if (!sibling.IsLeaf)
+        {
+            for (var i = 1; i <= sibling.KeyCount; i++)
+            {
+                sibling.Children[i - 1] = sibling.Children[i];
+            }
+        }
+
+        child.KeyCount++;
+        sibling.KeyCount--;
+    }
+
+    /// <summary>
+    ///     Merge a child with its sibling.
+    /// </summary>
+    /// <param name="node">Parent node.</param>
+    /// <param name="idx">Index of the child to merge.</param>
+    private void Merge(BTreeNode<TKey> node, int idx)
+    {
+        var child = node.Children[idx]!;
+        var sibling = node.Children[idx + 1]!;
+
+        child.Keys[MinimumDegree - 1] = node.Keys[idx];
+
+        for (var i = 0; i < sibling.KeyCount; i++)
+        {
+            child.Keys[i + MinimumDegree] = sibling.Keys[i];
+        }
+
+        if (!child.IsLeaf)
+        {
+            for (var i = 0; i <= sibling.KeyCount; i++)
+            {
+                child.Children[i + MinimumDegree] = sibling.Children[i];
+            }
+        }
+
+        for (var i = idx + 1; i < node.KeyCount; i++)
+        {
+            node.Keys[i - 1] = node.Keys[i];
+        }
+
+        for (var i = idx + 2; i <= node.KeyCount; i++)
+        {
+            node.Children[i - 1] = node.Children[i];
+        }
+
+        child.KeyCount += sibling.KeyCount + 1;
+        node.KeyCount--;
+    }
+
+    /// <summary>
+    ///     Get the minimum key in the subtree rooted at the given node.
+    /// </summary>
+    /// <param name="node">Root of the subtree.</param>
+    /// <returns>Minimum key in the subtree.</returns>
+    private TKey GetMin(BTreeNode<TKey> node)
+    {
+        while (!node.IsLeaf)
+        {
+            node = node.Children[0]!;
+        }
+
+        return node.Keys[0];
+    }
+
+    /// <summary>
+    ///     Get the maximum key in the subtree rooted at the given node.
+    /// </summary>
+    /// <param name="node">Root of the subtree.</param>
+    /// <returns>Maximum key in the subtree.</returns>
+    private TKey GetMax(BTreeNode<TKey> node)
+    {
+        while (!node.IsLeaf)
+        {
+            node = node.Children[node.KeyCount]!;
+        }
+
+        return node.Keys[node.KeyCount - 1];
+    }
+}
diff --git a/DataStructures/BTree/BTreeNode.cs b/DataStructures/BTree/BTreeNode.cs
new file mode 100644
index 00000000..382a341c
--- /dev/null
+++ b/DataStructures/BTree/BTreeNode.cs
@@ -0,0 +1,105 @@
+namespace DataStructures.BTree;
+
+/// <summary>
+///     Generic class to represent nodes in a <see cref="BTree{TKey}"/>
+///     instance.
+/// </summary>
+/// <typeparam name="TKey">The type of key for the node.</typeparam>
+/// <remarks>
+///     Initializes a new instance of the
+///     <see cref="BTreeNode{TKey}"/> class.
+/// </remarks>
+/// <param name="minDegree">Minimum degree of the B-Tree.</param>
+/// <param name="isLeaf">Whether this node is a leaf node.</param>
+internal class BTreeNode<TKey>(int minDegree, bool isLeaf)
+{
+    /// <summary>
+    ///     Gets the minimum degree (t) of the B-Tree.
+    ///     A node can contain at most 2t-1 keys and at least t-1 keys (except root).
+    /// </summary>
+    public int MinDegree { get; } = minDegree;
+
+    /// <summary>
+    ///     Gets or sets a value indicating whether this node is a leaf node.
+    /// </summary>
+    public bool IsLeaf { get; set; } = isLeaf;
+
+    /// <summary>
+    ///     Gets or sets the current number of keys stored in this node.
+    /// </summary>
+    public int KeyCount { get; internal set; }
+
+    /// <summary>
+    ///     Gets the array of keys stored in this node.
+    ///     Maximum size is 2*MinDegree - 1.
+    /// </summary>
+    public TKey[] Keys { get; } = new TKey[2 * minDegree - 1];
+
+    /// <summary>
+    ///     Gets the array of child pointers.
+    ///     Maximum size is 2*MinDegree.
+    /// </summary>
+    public BTreeNode<TKey>?[] Children { get; } = new BTreeNode<TKey>[2 * minDegree];
+
+    /// <summary>
+    ///     Inserts a key at the specified position in the keys array.
+    /// </summary>
+    /// <param name="index">Position to insert the key.</param>
+    /// <param name="key">Key to insert.</param>
+    public void InsertKey(int index, TKey key)
+    {
+        Keys[index] = key;
+        KeyCount++;
+    }
+
+    /// <summary>
+    ///     Removes the key at the specified position in the keys array.
+    /// </summary>
+    /// <param name="index">Position of the key to remove.</param>
+    public void RemoveKey(int index)
+    {
+        for (var i = index; i < KeyCount - 1; i++)
+        {
+            Keys[i] = Keys[i + 1];
+        }
+
+        Keys[KeyCount - 1] = default!;
+        KeyCount--;
+    }
+
+    /// <summary>
+    ///     Inserts a child pointer at the specified position.
+    /// </summary>
+    /// <param name="index">Position to insert the child.</param>
+    /// <param name="child">Child node to insert.</param>
+    public void InsertChild(int index, BTreeNode<TKey> child)
+    {
+        Children[index] = child;
+    }
+
+    /// <summary>
+    ///     Removes the child pointer at the specified position.
+    /// </summary>
+    /// <param name="index">Position of the child to remove.</param>
+    public void RemoveChild(int index)
+    {
+        for (var i = index; i < KeyCount; i++)
+        {
+            Children[i] = Children[i + 1];
+        }
+
+        Children[KeyCount] = null;
+    }
+
+    /// <summary>
+    ///     Checks if the node is full (contains maximum number of keys).
+    /// </summary>
+    /// <returns>True if the node is full, false otherwise.</returns>
+    public bool IsFull() => KeyCount == 2 * MinDegree - 1;
+
+    /// <summary>
+    ///     Checks if the node has minimum number of keys.
+    /// </summary>
+    /// <returns>True if the node has minimum keys, false otherwise.</returns>
+    public bool HasMinimumKeys() => KeyCount >= MinDegree - 1;
+}
diff --git a/README.md b/README.md
index 1b5de66b..0773c264 100644
--- a/README.md
+++ b/README.md
@@ -248,6 +248,8 @@ find more than one implementation for the same objective but using different alg
       * [Backtracking](./Algorithms/Problems/NQueens/BacktrackingNQueensSolver.cs)
     * [Knight Tour](./Algorithms/Problems/KnightTour/)
       * [Open Knight Tour](./Algorithms/Problems/KnightTour/OpenKnightTour.cs)
+    * [Graph Coloring](./Algorithms/Problems/GraphColoring)
+      * [Backtracking Graph Coloring Solver](./Algorithms/Problems/GraphColoring/GraphColoringSolver.cs)
     * [Dynamic Programming](./Algorithms/Problems/DynamicProgramming)
       * [Coin Change](./Algorithms/Problems/DynamicProgramming/CoinChange/DynamicCoinChangeSolver.cs)
       * [Levenshtein Distance](./Algorithms/Problems/DynamicProgramming/LevenshteinDistance/LevenshteinDistance.cs)
@@ -268,6 +270,7 @@ find more than one implementation for the same objective but using different alg
   * [Fenwick tree (or Binary Indexed Tree)](./DataStructures/Fenwick/BinaryIndexedTree.cs)
   * [AA Tree](./DataStructures/AATree)
   * [AVL Tree](./DataStructures/AVLTree)
+  * [B-Tree](./DataStructures/BTree)
   * [Red-Black Tree](./DataStructures/RedBlackTree)
   * [Stack](./DataStructures/Stack)
     * [Array-based Stack](./DataStructures/Stack/ArrayBasedStack.cs)

From cae9a4f49dcbc0f58a4c44c7173f013edf0b8ac8 Mon Sep 17 00:00:00 2001
From: ethanhaines <122860615+ethanhaines@users.noreply.github.com>
Date: Mon, 3 Nov 2025 17:40:48 -0500
Subject: [PATCH 2/3] Added more tests for full coverage

---
 DataStructures.Tests/BTreeTests.cs | 239 +++++++++++++++++++++++++++++
 DataStructures/BTree/BTreeNode.cs  |   6 -
 2 files changed, 239 insertions(+), 6 deletions(-)

diff --git a/DataStructures.Tests/BTreeTests.cs b/DataStructures.Tests/BTreeTests.cs
index ab201bce..12eebd07 100644
--- a/DataStructures.Tests/BTreeTests.cs
+++ b/DataStructures.Tests/BTreeTests.cs
@@ -564,4 +564,243 @@ public void BTree_InsertRemoveInsert_WorksCorrectly()
                 new[] { 1, 2, 3, 4, 5 },
                 config => config.WithStrictOrdering());
     }
+
+    [Test]
+    public void Remove_BorrowFromPreviousSibling_TreeStillValid()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.AddRange(new[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 });
+
+        tree.Remove(100);
+
+        tree.Count.Should().Be(9);
+        tree.Contains(100).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 10, 20, 30, 40, 50, 60, 70, 80, 90 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_BorrowFromNextSibling_TreeStillValid()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.AddRange(new[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 });
+
+        tree.Remove(10);
+
+        tree.Count.Should().Be(9);
+        tree.Contains(10).Should().BeFalse();
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 20, 30, 40, 50, 60, 70, 80, 90, 100 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_UsesPredecessor_TreeStillValid()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
+
+        var rootKeys = tree.GetKeysPreOrder().Take(3).ToArray();
+        var keyToRemove = rootKeys[0];
+
+        tree.Remove(keyToRemove);
+
+        tree.Contains(keyToRemove).Should().BeFalse();
+        tree.Count.Should().Be(14);
+
+        var inOrder = tree.GetKeysInOrder().ToArray();
+        inOrder.Should().HaveCount(14);
+        inOrder.Should().BeInAscendingOrder();
+    }
+
+    [Test]
+    public void Remove_UsesSuccessor_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+
+        tree.AddRange(new[] { 10, 20, 30, 40, 50, 60, 70 });
+
+        tree.Remove(40);
+
+        tree.Contains(40).Should().BeFalse();
+        tree.Count.Should().Be(6);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 10, 20, 30, 50, 60, 70 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_MergeWithSibling_TreeStillValid()
+    {
+        var tree = new BTree<int>(2);
+
+        tree.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+
+        tree.Remove(9);
+        tree.Remove(8);
+        tree.Remove(7);
+
+        tree.Count.Should().Be(6);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 3, 4, 5, 6 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_ComplexRebalancing_TreeStillValid()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.AddRange(Enumerable.Range(1, 30));
+
+        var keysToRemove = new[] { 5, 15, 25, 10, 20, 30, 1, 29 };
+
+        foreach (var key in keysToRemove)
+        {
+            tree.Remove(key);
+            tree.Contains(key).Should().BeFalse();
+        }
+
+        tree.Count.Should().Be(22);
+
+        var expected = Enumerable.Range(1, 30).Except(keysToRemove).OrderBy(x => x);
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                expected,
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void Remove_FromMinimumDegree3_AllRebalancingPaths()
+    {
+        var tree = new BTree<int>(3);
+
+        tree.AddRange(Enumerable.Range(1, 50));
+        var keysToRemove = new[] { 25, 12, 37, 6, 44, 18, 31, 3, 47, 15 };
+
+        foreach (var key in keysToRemove)
+        {
+            var countBefore = tree.Count;
+            tree.Remove(key);
+
+            tree.Count.Should().Be(countBefore - 1);
+            tree.Contains(key).Should().BeFalse();
+
+            var inOrder = tree.GetKeysInOrder().ToArray();
+            inOrder.Should().BeInAscendingOrder();
+        }
+
+        tree.Count.Should().Be(40);
+    }
+
+    [Test]
+    public void Remove_SequentialFromLargeTree_MaintainsStructure()
+    {
+        var tree = new BTree<int>(4);
+
+        tree.AddRange(Enumerable.Range(1, 100));
+        for (var i = 3; i <= 99; i += 3)
+        {
+            tree.Remove(i);
+        }
+
+        tree.Count.Should().Be(67);
+
+        var inOrder = tree.GetKeysInOrder().ToArray();
+        inOrder.Should().HaveCount(67);
+        inOrder.Should().BeInAscendingOrder();
+
+        tree.Contains(3).Should().BeFalse();
+        tree.Contains(6).Should().BeFalse();
+        tree.Contains(99).Should().BeFalse();
+        tree.Contains(1).Should().BeTrue();
+        tree.Contains(2).Should().BeTrue();
+        tree.Contains(100).Should().BeTrue();
+    }
+
+    [Test]
+    public void BTree_DegreeThree_CompleteInsertDeleteCycle()
+    {
+        var tree = new BTree<int>(3);
+
+        var keys = Enumerable.Range(1, 40).ToArray();
+        tree.AddRange(keys);
+        tree.Count.Should().Be(40);
+
+        for (var i = 2; i <= 40; i += 2)
+        {
+            tree.Remove(i);
+        }
+
+        tree.Count.Should().Be(20);
+
+        var remaining = tree.GetKeysInOrder().ToArray();
+        remaining.Should().BeEquivalentTo(
+            Enumerable.Range(1, 40).Where(x => x % 2 == 1),
+            config => config.WithStrictOrdering());
+
+        tree.Add(2);
+        tree.Add(4);
+        tree.Count.Should().Be(22);
+
+        tree.Contains(2).Should().BeTrue();
+        tree.Contains(4).Should().BeTrue();
+    }
+
+    [Test]
+    public void Remove_RootWithMultipleChildren_HandledCorrectly()
+    {
+        var tree = new BTree<int>(2);
+
+        tree.AddRange(new[] { 1, 2, 3, 4, 5 });
+        tree.Remove(3);
+        tree.Count.Should().Be(4);
+
+        tree.GetKeysInOrder()
+            .Should()
+            .BeEquivalentTo(
+                new[] { 1, 2, 4, 5 },
+                config => config.WithStrictOrdering());
+    }
+
+    [Test]
+    public void BTree_HighDegree_StressTest()
+    {
+        var tree = new BTree<int>(10);
+
+        tree.AddRange(Enumerable.Range(1, 200));
+        tree.Count.Should().Be(200);
+
+        for (var i = 10; i <= 200; i += 10)
+        {
+            tree.Remove(i);
+        }
+
+        tree.Count.Should().Be(180);
+
+        var inOrder = tree.GetKeysInOrder().ToArray();
+        inOrder.Should().HaveCount(180);
+        inOrder.Should().BeInAscendingOrder();
+
+        tree.Contains(10).Should().BeFalse();
+        tree.Contains(100).Should().BeFalse();
+        tree.Contains(200).Should().BeFalse();
+    }
 }
diff --git a/DataStructures/BTree/BTreeNode.cs b/DataStructures/BTree/BTreeNode.cs
index 382a341c..11c7d86f 100644
--- a/DataStructures/BTree/BTreeNode.cs
+++ b/DataStructures/BTree/BTreeNode.cs
@@ -96,10 +96,4 @@ public void RemoveChild(int index)
     /// </summary>
     /// <returns>True if the node is full, false otherwise.</returns>
     public bool IsFull() => KeyCount == 2 * MinDegree - 1;
-
-    /// <summary>
-    ///     Checks if the node has minimum number of keys.
-    /// </summary>
-    /// <returns>True if the node has minimum keys, false otherwise.</returns>
-    public bool HasMinimumKeys() => KeyCount >= MinDegree - 1;
 }

From 7a51c5310927f927db84017b3d938462064325e8 Mon Sep 17 00:00:00 2001
From: ethanhaines <122860615+ethanhaines@users.noreply.github.com>
Date: Mon, 3 Nov 2025 17:53:58 -0500
Subject: [PATCH 3/3] Fixed static code issues and increased test coverage

---
 DataStructures.Tests/BTreeTests.cs |  25 ++++++-
 DataStructures/BTree/BTree.cs      | 102 ++++++++++++++++++-----------
 DataStructures/BTree/BTreeNode.cs  |  14 ----
 3 files changed, 88 insertions(+), 53 deletions(-)

diff --git a/DataStructures.Tests/BTreeTests.cs b/DataStructures.Tests/BTreeTests.cs
index 12eebd07..5517ce32 100644
--- a/DataStructures.Tests/BTreeTests.cs
+++ b/DataStructures.Tests/BTreeTests.cs
@@ -34,6 +34,17 @@ public void Constructor_MinimumDegreeLessThan2_ThrowsException()
             .WithMessage("Minimum degree must be at least 2.*");
     }
 
+    [Test]
+    public void Constructor_CustomComparerMinimumDegreeLessThan2_ThrowsException()
+    {
+        var comparer = Comparer<int>.Create((x, y) => y.CompareTo(x));
+
+        Invoking(() => new BTree<int>(1, comparer))
+            .Should()
+            .ThrowExactly<ArgumentException>()
+            .WithMessage("Minimum degree must be at least 2.*");
+    }
+
     [Test]
     public void Constructor_UseCustomComparer_FormsCorrectTree()
     {
@@ -92,6 +103,18 @@ public void Add_DuplicateKey_ThrowsException()
             .WithMessage("""Key "3" already exists in B-Tree.""");
     }
 
+    [Test]
+    public void Add_DuplicateKeyInLeaf_ThrowsException()
+    {
+        var tree = new BTree<int>(3);
+        tree.AddRange(new[] { 10, 20 });
+
+        Invoking(() => tree.Add(10))
+            .Should()
+            .ThrowExactly<ArgumentException>()
+            .WithMessage("""Key "10" already exists in B-Tree.""");
+    }
+
     [Test]
     public void Add_CausesNodeSplit_TreeStillValid()
     {
@@ -753,7 +776,7 @@ public void BTree_DegreeThree_CompleteInsertDeleteCycle()
 
         var remaining = tree.GetKeysInOrder().ToArray();
         remaining.Should().BeEquivalentTo(
-            Enumerable.Range(1, 40).Where(x => x % 2 == 1),
+            Enumerable.Range(1, 40).Where(x => x % 2 != 0),
             config => config.WithStrictOrdering());
 
         tree.Add(2);
diff --git a/DataStructures/BTree/BTree.cs b/DataStructures/BTree/BTree.cs
index 5efdf227..7ff58e50 100644
--- a/DataStructures/BTree/BTree.cs
+++ b/DataStructures/BTree/BTree.cs
@@ -345,50 +345,83 @@ void PostOrderTraversal(BTreeNode<TKey>? node)
     /// </exception>
     private void InsertNonFull(BTreeNode<TKey> node, TKey key)
     {
-        var i = node.KeyCount - 1;
-
         if (node.IsLeaf)
         {
-            while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
-            {
-                node.Keys[i + 1] = node.Keys[i];
-                i--;
-            }
+            InsertIntoLeaf(node, key);
+        }
+        else
+        {
+            InsertIntoNonLeaf(node, key);
+        }
+    }
 
-            if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
-            {
-                throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
-            }
+    /// <summary>
+    ///     Insert a key into a leaf node.
+    /// </summary>
+    /// <param name="node">Leaf node to insert into.</param>
+    /// <param name="key">Key to insert.</param>
+    private void InsertIntoLeaf(BTreeNode<TKey> node, TKey key)
+    {
+        var i = node.KeyCount - 1;
 
-            node.Keys[i + 1] = key;
-            node.KeyCount++;
+        while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
+        {
+            node.Keys[i + 1] = node.Keys[i];
+            i--;
         }
-        else
+
+        if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
         {
-            while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
-            {
-                i--;
-            }
+            throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
+        }
+
+        node.Keys[i + 1] = key;
+        node.KeyCount++;
+    }
 
-            if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
+    /// <summary>
+    ///     Insert a key into a non-leaf node.
+    /// </summary>
+    /// <param name="node">Non-leaf node to insert into.</param>
+    /// <param name="key">Key to insert.</param>
+    private void InsertIntoNonLeaf(BTreeNode<TKey> node, TKey key)
+    {
+        var i = FindInsertionIndex(node, key);
+
+        if (node.Children[i]!.IsFull())
+        {
+            SplitChild(node, i);
+
+            if (comparer.Compare(key, node.Keys[i]) > 0)
             {
-                throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
+                i++;
             }
+        }
 
-            i++;
+        InsertNonFull(node.Children[i]!, key);
+    }
 
-            if (node.Children[i]!.IsFull())
-            {
-                SplitChild(node, i);
+    /// <summary>
+    ///     Find the index where a key should be inserted in a non-leaf node.
+    /// </summary>
+    /// <param name="node">Node to search in.</param>
+    /// <param name="key">Key to insert.</param>
+    /// <returns>Index where the key should be inserted.</returns>
+    private int FindInsertionIndex(BTreeNode<TKey> node, TKey key)
+    {
+        var i = node.KeyCount - 1;
 
-                if (comparer.Compare(key, node.Keys[i]) > 0)
-                {
-                    i++;
-                }
-            }
+        while (i >= 0 && comparer.Compare(key, node.Keys[i]) < 0)
+        {
+            i--;
+        }
 
-            InsertNonFull(node.Children[i]!, key);
+        if (i >= 0 && comparer.Compare(key, node.Keys[i]) == 0)
+        {
+            throw new ArgumentException($"""Key "{key}" already exists in B-Tree.""");
         }
+
+        return i + 1;
     }
 
     /// <summary>
@@ -588,14 +621,7 @@ private void Fill(BTreeNode<TKey> node, int idx)
         }
         else
         {
-            if (idx != node.KeyCount)
-            {
-                Merge(node, idx);
-            }
-            else
-            {
-                Merge(node, idx - 1);
-            }
+            Merge(node, idx != node.KeyCount ? idx : idx - 1);
         }
     }
 
diff --git a/DataStructures/BTree/BTreeNode.cs b/DataStructures/BTree/BTreeNode.cs
index 11c7d86f..e104d64b 100644
--- a/DataStructures/BTree/BTreeNode.cs
+++ b/DataStructures/BTree/BTreeNode.cs
@@ -77,20 +77,6 @@ public void InsertChild(int index, BTreeNode<TKey> child)
         Children[index] = child;
     }
 
-    /// <summary>
-    ///     Removes the child pointer at the specified position.
-    /// </summary>
-    /// <param name="index">Position of the child to remove.</param>
-    public void RemoveChild(int index)
-    {
-        for (var i = index; i < KeyCount; i++)
-        {
-            Children[i] = Children[i + 1];
-        }
-
-        Children[KeyCount] = null;
-    }
-
     /// <summary>
     ///     Checks if the node is full (contains maximum number of keys).
     /// </summary>