public void Set_Test()
{
// Arrange
RedBlackTree <int> redBlackTree = new RedBlackTree <int>();
BPTree <int, int> bPlusTree = new BPTree <int, int>();
// Act
for (int i = 0; i < 100; i++)
{
redBlackTree.Add(i);
}
for (int i = 50; i < 150; i++)
{
bPlusTree.Add(i, i);
}
Set <int> bpTreeSet = new Set <int>(bPlusTree);
Set <int> rbTreeSet = new Set <int>(redBlackTree);
Set <int> checkSet = new Set <int>();
for (int i = 0; i < 50; i++)
{
checkSet.Add(i);
checkSet.Add(i + 100);
}
// Assert
Assert.IsTrue(bpTreeSet.SymmetricExceptWith(rbTreeSet).set.SetEquals(checkSet.set));
}
public Container(BPTree <TKey, TValue> bpTree)
{
foreach (var element in bpTree.AsPairEnumerable())
{
dictionary[element.Key] = element.Value;
}
}
public void Container_BPTree()
{
// Arrange
BPTree <int, int> bpTree = new BPTree <int, int>();
// Act
for (int i = 0; i < 100; i++)
{
bpTree.Add(100 + i, i);
}
Container <int, int> container = new Container <int, int>(bpTree);
container.RemoveByKey(120);
container.RemoveByKey(180);
// Assert
for (int i = 100; i < 200; i++)
{
if (i != 120 && i != 180)
{
Assert.AreEqual(container.GetValue(i), i - 100);
}
else
{
Assert.AreEqual(container.GetValue(i), default);
}
}
}
public Set(BPTree <TValue, TValue> bpTree)
{
foreach (var element in bpTree)
{
set.Add(element);
}
}
public void BPTree_IENumerator()
{
// Arrange
var tree = new BPTree <int, int>();
// Act
for (int i = 0; i < 100; i++)
{
tree.Add(i, i);
}
// Assert
int prevElement = -1;
foreach (var element in tree)
{
Assert.IsTrue(element > prevElement);
prevElement = element;
}
}
public void BPTree_StressTest()
{
var nodeCount = 1000 * 10;
var rnd = new Random();
var randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
var tree = new BPTree <int>(12);
for (int i = 0; i < nodeCount; i++)
{
tree.Insert(randomNumbers[i]);
Assert.IsTrue(tree.Count == i + 1);
}
////shuffle again before deletion tests
randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
//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)
{
Assert.AreEqual(j, element);
j++;
}
for (int i = 0; i < nodeCount; i++)
{
tree.Delete(randomNumbers[i]);
Assert.IsTrue(tree.Count == nodeCount - 1 - i);
}
Assert.IsTrue(tree.Count == 0);
}
public void BPTree_BuildDeleteTryGet()
{
// Arrange
var tree = new BPTree <int, int>();
int res;
// Act
for (int i = 99; i >= 0; i--)
{
tree.Add(i, i);
}
// Assert
for (int i = 0; i < 100; i++)
{
tree.TryGet(i, out res);
Assert.AreEqual(res, i);
}
int removeResult;
Assert.IsTrue(tree.Remove(5, out removeResult));
Assert.IsFalse(tree.Remove(137, out removeResult));
Assert.IsFalse(tree.TryGet(137, out res));
}
public void BPTree_AccuracyTest()
{
var nodeCount = 1000;
var rnd = new Random();
var randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
var order = 5;
var tree = new BPTree <int>(order);
for (int i = 0; i < nodeCount; i++)
{
tree.Insert(randomNumbers[i]);
var actualMaxHeight = BTreeTester.GetMaxHeight(tree.Root);
var actualMinHeight = BTreeTester.GetMinHeight(tree.Root);
Assert.IsTrue(actualMaxHeight == actualMinHeight);
//https://en.wikipedia.org/wiki/B-tree#Best_case_and_worst_case_heights
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.IsTrue(tree.HasItem(randomNumbers[i]));
}
for (int i = 0; i < nodeCount; i++)
{
Assert.IsTrue(tree.HasItem(randomNumbers[i]));
}
Assert.AreEqual(tree.Max, randomNumbers.Max());
Assert.AreEqual(tree.Min, randomNumbers.Min());
//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)
{
Assert.AreEqual(j, element);
j++;
}
//shuffle again before deletion tests
randomNumbers = Enumerable.Range(1, nodeCount)
.OrderBy(x => rnd.Next())
.ToList();
for (int i = 0; i < nodeCount; i++)
{
tree.Delete(randomNumbers[i]);
Assert.IsFalse(tree.HasItem(randomNumbers[i]));
var actualMaxHeight = BTreeTester.GetMaxHeight(tree.Root);
var actualMinHeight = BTreeTester.GetMinHeight(tree.Root);
Assert.IsTrue(actualMaxHeight == actualMinHeight);
//https://en.wikipedia.org/wiki/B-tree#Best_case_and_worst_case_heights
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.IsTrue(BTreeTester.GetMaxHeight(tree.Root) == 0);
Assert.IsTrue(tree.Count == 0);
}
public void BPTree_Smoke_Test()
{
//insert test
var tree = new BPTree <int>(3);
tree.Insert(5);
tree.Insert(3);
tree.Insert(21);
tree.Insert(9);
tree.Insert(1);
tree.Insert(5);
tree.Insert(13);
tree.Insert(2);
tree.Insert(7);
tree.Insert(10);
tree.Insert(12);
tree.Insert(4);
tree.Insert(8);
//////delete
tree.Delete(2);
Assert.IsFalse(tree.HasItem(2));
tree.Delete(21);
Assert.IsFalse(tree.HasItem(21));
tree.Delete(10);
Assert.IsFalse(tree.HasItem(10));
tree.Delete(3);
Assert.IsFalse(tree.HasItem(3));
tree.Delete(4);
Assert.IsFalse(tree.HasItem(4));
tree.Delete(7);
Assert.IsFalse(tree.HasItem(7));
tree.Delete(9);
Assert.IsFalse(tree.HasItem(9));
tree.Delete(1);
Assert.IsFalse(tree.HasItem(1));
tree.Delete(5);
Assert.IsTrue(tree.HasItem(5));
tree.Delete(5);
Assert.IsFalse(tree.HasItem(5));
tree.Delete(8);
Assert.IsFalse(tree.HasItem(8));
tree.Delete(13);
Assert.IsFalse(tree.HasItem(13));
tree.Delete(12);
Assert.IsFalse(tree.HasItem(12));
Assert.AreEqual(tree.Count, 0);
}
public Builder(SparseArray <K, T> tree)
{
builder = new BPTree <K, RingArray <T> > .Builder(tree);
}
